seecoder-devcloud/api/src/main/java/seecoder/devcloud/api/k8s/model/Ingress.java

package seecoder.devcloud.api.k8s.model;

import io.kubernetes.client.custom.IntOrString;
import io.kubernetes.client.openapi.models.*;
import lombok.*;

import java.util.*;
import java.util.stream.Collectors;

/**
 * author: rale
 * createdAt: 1/5/19
 * @// TODO: 3/25/19 添加标签字段 以后应当是一个分支上的代码可以创建一个deployment 
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@EqualsAndHashCode(callSuper=true)
public class Ingress extends K8sAbstractObject<ExtensionsV1beta1Ingress> {

    public static final String API_VERSION = "extensions/v1beta1";

    private static final String KIND = "Ingress";

    public static final String REWRITE_ANNOTATION = "nginx.ingress.kubernetes.io/rewrite-target";

    public static final String DEFAULT_REWRITE_PATH = "/";

    //重定向的路径，默认为根路径
    private static final String redirectPath = DEFAULT_REWRITE_PATH;

    @Builder.Default
    /*Ingress能暴露HTTP和HTTPS协议口，目前暂不支持HTTPS协议*/
    private List<IngressRule> httpRules = new ArrayList<>();

    public Ingress(ExtensionsV1beta1Ingress extensionsV1beta1Ingress) {
        super(extensionsV1beta1Ingress);
        List<ExtensionsV1beta1IngressRule> rules = extensionsV1beta1Ingress.getSpec().getRules();
        if (rules != null && !rules.isEmpty()) {
            httpRules = rules.stream()
                    .filter(Objects::nonNull)
                    .map(IngressRule::new)
                    .collect(Collectors.toList());
        }
    }

    @Override
    public ExtensionsV1beta1Ingress toK8sObject() {
        ExtensionsV1beta1IngressSpec ExtensionsV1beta1IngressSpec = new ExtensionsV1beta1IngressSpecBuilder()
                .withRules(toExtensionsV1beta1IngressRules())
                .build();
        ExtensionsV1beta1Ingress ExtensionsV1beta1Ingress = new ExtensionsV1beta1IngressBuilder()
                .withApiVersion(getApiVersion() == null ? API_VERSION : getApiVersion())
                .withKind(getKind() == null ? KIND : getKind())
                .withMetadata(this.toV1ObjectMeta())
                .withSpec(ExtensionsV1beta1IngressSpec)
                .build();
        return ExtensionsV1beta1Ingress;
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @EqualsAndHashCode
    @Builder
    public static class IngressPath implements K8sObjectTransformer<ExtensionsV1beta1HTTPIngressPath> {

        private String path;

        private String serviceName;

        private int port;

        public IngressPath(ExtensionsV1beta1HTTPIngressPath path) {
            this.path = path.getPath();
            this.serviceName = path.getBackend().getServiceName();
            this.port = path.getBackend().getServicePort().getIntValue();
        }

        @Override
        public ExtensionsV1beta1HTTPIngressPath toK8sObject() {
            ExtensionsV1beta1HTTPIngressPath v1beta1HTTPIngressPath = new ExtensionsV1beta1HTTPIngressPath();
            v1beta1HTTPIngressPath.setPath(getPath());

            ExtensionsV1beta1IngressBackend ExtensionsV1beta1IngressBackend = new ExtensionsV1beta1IngressBackend();
            ExtensionsV1beta1IngressBackend.setServiceName(serviceName);
            ExtensionsV1beta1IngressBackend.setServicePort(new IntOrString(port));

            v1beta1HTTPIngressPath.setBackend(ExtensionsV1beta1IngressBackend);

            return v1beta1HTTPIngressPath;
        }
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @EqualsAndHashCode
    @Builder
    public static class IngressRule implements K8sObjectTransformer<ExtensionsV1beta1IngressRule> {

        private String host;

        @Builder.Default
        private Set<IngressPath> ruleValues = new HashSet<>();

        public IngressRule(String host) {
            this.host = host;
        }

        public void addRuleValue(IngressPath ingressPath) {
            this.ruleValues.add(ingressPath);
        }

        public IngressRule(ExtensionsV1beta1IngressRule ExtensionsV1beta1IngressRule) {
            this.host = ExtensionsV1beta1IngressRule.getHost();
            if (ExtensionsV1beta1IngressRule.getHttp() != null) {
                this.ruleValues = ExtensionsV1beta1IngressRule.getHttp() != null && ExtensionsV1beta1IngressRule.getHttp()
                        .getPaths() != null ? ExtensionsV1beta1IngressRule.getHttp()
                        .getPaths()
                        .stream()
                        .map(IngressPath::new)
                        .collect(Collectors.toSet()) : null;
            }

        }

        private ExtensionsV1beta1HTTPIngressRuleValue toV1beta1HTTPIngressRuleValue() {
            List<ExtensionsV1beta1HTTPIngressPath> paths = ruleValues == null ? null : ruleValues.stream()
                    .map(IngressPath::toK8sObject)
                    .collect(Collectors.toList());

            return new ExtensionsV1beta1HTTPIngressRuleValueBuilder()
                    .withPaths(paths)
                    .build();
        }

        @Override
        public ExtensionsV1beta1IngressRule toK8sObject() {
            return new ExtensionsV1beta1IngressRuleBuilder()
                    .withHost(host)
                    .withHttp(toV1beta1HTTPIngressRuleValue())
                    .build();
        }
    }

    private List<ExtensionsV1beta1IngressRule> toExtensionsV1beta1IngressRules() {
        return httpRules.stream()
                .map(IngressRule::toK8sObject)
                .collect(Collectors.toList());

    }
}