kaniop-operator 0.0.0-beta.6

Core library for the Kanidm Kubernetes operator
Documentation
use crate::kanidm::crd::Kanidm;

use k8s_openapi::api::networking::v1::{
    HTTPIngressPath, HTTPIngressRuleValue, Ingress, IngressBackend, IngressRule,
    IngressServiceBackend, IngressSpec, IngressTLS, ServiceBackendPort,
};
use kube::ResourceExt;
use kube::api::{ObjectMeta, Resource};

pub trait IngressExt {
    fn create_ingress(&self) -> Option<Ingress>;
}

impl IngressExt for Kanidm {
    fn create_ingress(&self) -> Option<Ingress> {
        self.spec.ingress.clone().map(|ingress| {
            let labels = self
                .generate_resource_labels()
                .clone()
                .into_iter()
                .chain(self.labels().clone())
                .collect();

            let tls_hosts: Vec<String> = std::iter::once(self.spec.domain.clone())
                .chain(ingress.extra_tls_hosts.clone().unwrap_or_default())
                .collect();
            Ingress {
                metadata: ObjectMeta {
                    name: Some(self.name_any()),
                    namespace: Some(self.namespace().unwrap()),
                    labels: Some(labels),
                    annotations: ingress.annotations.clone(),
                    owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
                    ..ObjectMeta::default()
                },
                spec: Some(IngressSpec {
                    ingress_class_name: ingress.ingress_class_name.clone(),
                    rules: Some(vec![IngressRule {
                        host: Some(self.spec.domain.clone()),
                        http: Some(HTTPIngressRuleValue {
                            paths: vec![HTTPIngressPath {
                                backend: IngressBackend {
                                    service: Some(IngressServiceBackend {
                                        name: self.name_any(),
                                        port: Some(ServiceBackendPort {
                                            name: Some(self.spec.port_name.clone()),
                                            ..ServiceBackendPort::default()
                                        }),
                                    }),
                                    ..IngressBackend::default()
                                },
                                path: Some("/".to_string()),
                                path_type: "Prefix".to_string(),
                            }],
                        }),
                    }]),
                    tls: Some(vec![IngressTLS {
                        hosts: Some(tls_hosts),
                        secret_name: Some(
                            ingress
                                .tls_secret_name
                                .unwrap_or_else(|| self.get_tls_secret_name()),
                        ),
                    }]),
                    ..IngressSpec::default()
                }),
                ..Ingress::default()
            }
        })
    }
}