Make ResourcePatcher applicable for Deployment and Statefulset

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

 package theodolite.patcher
 
+import io.fabric8.kubernetes.api.model.Container
 import io.fabric8.kubernetes.api.model.KubernetesResource
 import io.fabric8.kubernetes.api.model.Quantity
 import io.fabric8.kubernetes.api.model.ResourceRequirements
 import io.fabric8.kubernetes.api.model.apps.Deployment
-import javax.validation.constraints.Null
+import io.fabric8.kubernetes.api.model.apps.StatefulSet
+import java.lang.IllegalArgumentException
 
 class ResourceLimitPatcher(
     private val k8sResource: KubernetesResource,
@@ -13,24 +15,38 @@ class ResourceLimitPatcher(
 ) : AbstractPatcher(k8sResource, container, limitedResource) {
 
     override fun <String> patch(value: String) {
-        if (k8sResource is Deployment) {
+        when (k8sResource) {
+            is Deployment -> {
                 k8sResource.spec.template.spec.containers.filter { it.name == container }.forEach {
-                when {
-                    it.resources == null -> {
-                        val resource = ResourceRequirements()
-                        resource.limits = mapOf(limitedResource to Quantity(value as kotlin.String))
-                        it.resources = resource
+                    setLimits(it, value as kotlin.String)
+                }
+            }
+            is StatefulSet -> {
+                k8sResource.spec.template.spec.containers.filter { it.name == container }.forEach {
+                    setLimits(it, value as kotlin.String)
                 }
-                    it.resources.limits.isEmpty() -> {
-                        it.resources.limits = mapOf(limitedResource to Quantity(value as kotlin.String))
             }
             else -> {
-                        val values = mutableMapOf<kotlin.String, Quantity>()
-                        it.resources.limits.forEach { entry -> values[entry.key] = entry.value }
-                        values[limitedResource] = Quantity(value as kotlin.String)
-                        it.resources.limits = values
+                throw IllegalArgumentException("ResourceLimitPatcher not applicable for $k8sResource")
+            }
         }
     }
+
+    private fun setLimits(container: Container, value: String) {
+        when {
+            container.resources == null -> {
+                val resource = ResourceRequirements()
+                resource.limits = mapOf(limitedResource to Quantity(value))
+                container.resources = resource
+            }
+            container.resources.limits.isEmpty() -> {
+                container.resources.limits = mapOf(limitedResource to Quantity(value))
+            }
+            else -> {
+                val values = mutableMapOf<String, Quantity>()
+                container.resources.limits.forEach { entry -> values[entry.key] = entry.value }
+                values[limitedResource] = Quantity(value)
+                container.resources.limits = values
             }
         }
     }

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

 package theodolite.patcher
 
+import io.fabric8.kubernetes.api.model.Container
 import io.fabric8.kubernetes.api.model.KubernetesResource
 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
 
 class ResourceRequestPatcher(
     private val k8sResource: KubernetesResource,
@@ -12,24 +15,38 @@ class ResourceRequestPatcher(
 ) : AbstractPatcher(k8sResource, container, requestedResource) {
 
     override fun <String> patch(value: String) {
-        if (k8sResource is Deployment) {
+        when (k8sResource) {
+            is Deployment -> {
                 k8sResource.spec.template.spec.containers.filter { it.name == container }.forEach {
-                when {
-                    it.resources == null -> {
-                        val resource = ResourceRequirements()
-                        resource.requests = mapOf(requestedResource to Quantity(value as kotlin.String))
-                        it.resources = resource
+                    setRequests(it, value as kotlin.String)
+                }
+            }
+            is StatefulSet -> {
+                k8sResource.spec.template.spec.containers.filter { it.name == container }.forEach {
+                    setRequests(it, value as kotlin.String)
                 }
-                    it.resources.requests.isEmpty() -> {
-                        it.resources.requests = mapOf(requestedResource to Quantity(value as kotlin.String))
             }
             else -> {
-                        val values = mutableMapOf<kotlin.String, Quantity>()
-                        it.resources.requests.forEach { entry -> values[entry.key] = entry.value }
-                        values[requestedResource] = Quantity(value as kotlin.String)
-                        it.resources.requests = values
+                throw IllegalArgumentException("ResourceRequestPatcher not applicable for $k8sResource")
+            }
         }
     }
+
+    private fun setRequests(container: Container, value: String) {
+        when {
+            container.resources == null -> {
+                val resource = ResourceRequirements()
+                resource.requests = mapOf(requestedResource to Quantity(value))
+                container.resources = resource
+            }
+            container.resources.requests.isEmpty() -> {
+                container.resources.requests = mapOf(requestedResource to Quantity(value))
+            }
+            else -> {
+                val values = mutableMapOf<String, Quantity>()
+                container.resources.requests.forEach { entry -> values[entry.key] = entry.value }
+                values[requestedResource] = Quantity(value)
+                container.resources.requests = values
             }
         }
     }