Fix eclipse-jkube#551: Add Configuration options to IngressEnricher

Signed-off-by: Rohan Kumar <rohaan@redhat.com>
rohanKanojia · Jun 15, 2021 · dea9187 · dea9187
1 parent b733594
commit dea9187
Show file tree

Hide file tree

Showing 9 changed files with 735 additions and 182 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -24,6 +24,7 @@ Usage:
 * Fix #705: JIB assembly works on Windows
 * Fix #714: feat: Helm support for Golang expressions
 * Port fabric8io/docker-maven-plugin#1318: Update ECR autorization token URL
+* Fix #551: Add Configuration options to IngressEnricher
 
 ### 1.3.0
 * Fix #497: Assembly descriptor removed but still in documentation

diff --git a/...c/src/main/java/org/eclipse/jkube/enricher/generic/ExtensionsV1beta1IngressGenerator.java b/...c/src/main/java/org/eclipse/jkube/enricher/generic/ExtensionsV1beta1IngressGenerator.java
@@ -0,0 +1,173 @@
+/**
+ * Copyright (c) 2019 Red Hat, Inc.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at:
+ *
+ *     https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Red Hat, Inc. - initial API and implementation
+ */
+package org.eclipse.jkube.enricher.generic;
+
+import io.fabric8.kubernetes.api.model.IntOrString;
+import io.fabric8.kubernetes.api.model.KubernetesListBuilder;
+import io.fabric8.kubernetes.api.model.ObjectMeta;
+import io.fabric8.kubernetes.api.model.ServiceBuilder;
+import io.fabric8.kubernetes.api.model.extensions.HTTPIngressPath;
+import io.fabric8.kubernetes.api.model.extensions.HTTPIngressPathBuilder;
+import io.fabric8.kubernetes.api.model.extensions.HTTPIngressRuleValueBuilder;
+import io.fabric8.kubernetes.api.model.extensions.Ingress;
+import io.fabric8.kubernetes.api.model.extensions.IngressBackend;
+import io.fabric8.kubernetes.api.model.extensions.IngressBackendBuilder;
+import io.fabric8.kubernetes.api.model.extensions.IngressBuilder;
+import io.fabric8.kubernetes.api.model.extensions.IngressRule;
+import io.fabric8.kubernetes.api.model.extensions.IngressRuleBuilder;
+import io.fabric8.kubernetes.api.model.extensions.IngressSpec;
+import io.fabric8.kubernetes.api.model.extensions.IngressSpecBuilder;
+import io.fabric8.kubernetes.api.model.extensions.IngressTLS;
+import io.fabric8.kubernetes.api.model.extensions.IngressTLSBuilder;
+import org.apache.commons.lang3.StringUtils;
+import org.eclipse.jkube.kit.common.KitLogger;
+import org.eclipse.jkube.kit.common.util.KubernetesHelper;
+import org.eclipse.jkube.kit.config.resource.IngressRuleConfig;
+import org.eclipse.jkube.kit.config.resource.IngressRulePathConfig;
+import org.eclipse.jkube.kit.config.resource.IngressRulePathResourceConfig;
+import org.eclipse.jkube.kit.config.resource.IngressTlsConfig;
+
+import java.util.List;
+import java.util.Objects;
+
+import static org.eclipse.jkube.enricher.generic.IngressEnricher.getIngressMetadata;
+import static org.eclipse.jkube.enricher.generic.IngressEnricher.getServicePort;
+import static org.eclipse.jkube.enricher.generic.IngressEnricher.hasIngress;
+import static org.eclipse.jkube.enricher.generic.IngressEnricher.resolveIngressHost;
+import static org.eclipse.jkube.enricher.generic.IngressEnricher.shouldCreateExternalURLForService;
+import static org.eclipse.jkube.kit.enricher.api.util.KubernetesResourceUtil.isExposedService;
+
+public class ExtensionsV1beta1IngressGenerator {
+    private ExtensionsV1beta1IngressGenerator() { }
+
+    protected static Ingress generate(KubernetesListBuilder listBuilder, ServiceBuilder serviceBuilder, String routeDomainPostfix, String host, List<IngressRuleConfig> ingressRuleConfigs, List<IngressTlsConfig> ingressTlsConfigs, KitLogger log) {
+        ObjectMeta serviceMetadata = serviceBuilder.buildMetadata();
+        if (serviceMetadata == null) {
+            log.info("No Metadata for service! ");
+        }
+        if (isExposedService(serviceMetadata) && shouldCreateExternalURLForService(serviceBuilder, log)) {
+            Objects.requireNonNull(serviceMetadata);
+            String serviceName = serviceMetadata.getName();
+            if (!hasIngress(listBuilder, serviceName)) {
+                Integer servicePort = getServicePort(serviceBuilder);
+                if (servicePort != null) {
+                    return new IngressBuilder()
+                            .withMetadata(getIngressMetadata(serviceMetadata))
+                            .withSpec(getIngressSpec(routeDomainPostfix, host, serviceName, servicePort, ingressRuleConfigs, ingressTlsConfigs))
+                            .build();
+
+                }
+            }
+        }
+        return null;
+    }
+
+    private static IngressSpec getIngressSpec(String routeDomainPostfix, String host, String serviceName, Integer servicePort, List<IngressRuleConfig> ingressRuleConfig, List<IngressTlsConfig> ingressTlsConfigs) {
+        if (ingressRuleConfig == null || ingressRuleConfig.isEmpty()) {
+            return getOpinionatedIngressSpec(routeDomainPostfix, host, serviceName, servicePort);
+        }
+        return getXmlConfiguredIngressSpec(ingressRuleConfig, ingressTlsConfigs);
+    }
+
+    private static IngressSpec getXmlConfiguredIngressSpec(List<IngressRuleConfig> ingressRuleConfigs, List<IngressTlsConfig> ingressTlsConfigs) {
+        IngressSpecBuilder ingressSpecBuilder = new IngressSpecBuilder();
+        for (IngressRuleConfig ingressRuleConfig: ingressRuleConfigs) {
+            IngressRule ingressRule = getIngressRuleFromXmlConfig(ingressRuleConfig);
+            ingressSpecBuilder.addToRules(ingressRule);
+        }
+
+        for (IngressTlsConfig ingressTlsConfig : ingressTlsConfigs) {
+            IngressTLS ingressTLS = getIngressTlsFromXMLConfig(ingressTlsConfig);
+            ingressSpecBuilder.addToTls(ingressTLS);
+        }
+        return ingressSpecBuilder.build();
+    }
+
+    private static IngressTLS getIngressTlsFromXMLConfig(IngressTlsConfig ingressTlsConfig) {
+        IngressTLSBuilder ingressTLSBuilder = new IngressTLSBuilder();
+        if (ingressTlsConfig.getHosts() != null && !ingressTlsConfig.getHosts().isEmpty()) {
+            ingressTLSBuilder.withHosts(ingressTlsConfig.getHosts());
+        }
+        if (ingressTlsConfig.getSecretName() != null) {
+            ingressTLSBuilder.withSecretName(ingressTlsConfig.getSecretName());
+        }
+        return ingressTLSBuilder.build();
+    }
+
+    private static IngressSpec getOpinionatedIngressSpec(String routeDomainPostfix, String host, String serviceName, Integer servicePort) {
+        IngressSpecBuilder ingressSpecBuilder = new IngressSpecBuilder();
+        if (StringUtils.isNotBlank(routeDomainPostfix) || StringUtils.isNotBlank(host)) {
+            ingressSpecBuilder.addNewRule()
+                    .withHost(resolveIngressHost(serviceName, routeDomainPostfix, host))
+                    .withNewHttp()
+                    .withPaths(new HTTPIngressPathBuilder()
+                            .withNewBackend()
+                            .withServiceName(serviceName)
+                            .withServicePort(KubernetesHelper.createIntOrString(servicePort))
+                            .endBackend()
+                            .build())
+                    .endHttp()
+                    .endRule().build();
+        } else {
+            ingressSpecBuilder.withBackend(new IngressBackendBuilder().
+                    withNewServiceName(serviceName)
+                    .withNewServicePort(servicePort)
+                    .build());
+        }
+        return ingressSpecBuilder.build();
+    }
+
+    private static IngressRule getIngressRuleFromXmlConfig(IngressRuleConfig ingressRuleConfig) {
+        IngressRuleBuilder ingressRuleBuilder = new IngressRuleBuilder();
+        if (ingressRuleConfig.getHost() != null) {
+            ingressRuleBuilder.withHost(ingressRuleConfig.getHost());
+        }
+        if (ingressRuleConfig.getPaths() != null && !ingressRuleConfig.getPaths().isEmpty()) {
+            HTTPIngressRuleValueBuilder httpIngressPathBuilder = new HTTPIngressRuleValueBuilder();
+            for (IngressRulePathConfig ingressRulePathConfig : ingressRuleConfig.getPaths()) {
+                httpIngressPathBuilder.addToPaths(getHTTPIngressPath(ingressRulePathConfig));
+            }
+            ingressRuleBuilder.withHttp(httpIngressPathBuilder.build());
+        }
+        return ingressRuleBuilder.build();
+    }
+
+    private static HTTPIngressPath getHTTPIngressPath(IngressRulePathConfig ingressRulePathConfig) {
+        HTTPIngressPathBuilder httpIngressPathBuilder = new HTTPIngressPathBuilder();
+        if (ingressRulePathConfig.getPath() != null) {
+            httpIngressPathBuilder.withPath(ingressRulePathConfig.getPath());
+        }
+        if (ingressRulePathConfig.getPathType() != null) {
+            httpIngressPathBuilder.withPathType(ingressRulePathConfig.getPathType());
+        }
+        return httpIngressPathBuilder.withBackend(getIngressBackend(ingressRulePathConfig))
+                .build();
+    }
+
+    private static IngressBackend getIngressBackend(IngressRulePathConfig ingressRulePathConfig) {
+        IngressBackendBuilder ingressBackendBuilder = new IngressBackendBuilder();
+        if (ingressRulePathConfig.getServiceName() != null) {
+            ingressBackendBuilder.withServiceName(ingressRulePathConfig.getServiceName());
+        }
+        if (ingressRulePathConfig.getServicePort() > 0) {
+            ingressBackendBuilder.withServicePort(new IntOrString(ingressRulePathConfig.getServicePort()));
+        }
+        if (ingressRulePathConfig.getResource() != null) {
+            IngressRulePathResourceConfig resource = ingressRulePathConfig.getResource();
+            ingressBackendBuilder.withNewResource(resource.getApiGroup(), resource.getKind(), resource.getName());
+        }
+
+        return ingressBackendBuilder.build();
+    }
+}