#
k8s_openapi/v1_35/api/networking/v1/
ingress_tls.rs

    1// Generated from definition io.k8s.api.networking.v1.IngressTLS
    2
    3/// IngressTLS describes the transport layer security associated with an ingress.
    4#[derive(Clone, Debug, Default, PartialEq)]
    5pub struct IngressTLS {
    6    /// hosts is a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified.
    7    pub hosts: Option<std::vec::Vec<std::string::String>>,
    8
    9    /// secretName is the name of the secret used to terminate TLS traffic on port 443. Field is left optional to allow TLS routing based on SNI hostname alone. If the SNI host in a listener conflicts with the "Host" header field used by an IngressRule, the SNI host is used for termination and value of the "Host" header is used for routing.
    10    pub secret_name: Option<std::string::String>,
    11}
    12
    13impl crate::DeepMerge for IngressTLS {
    14    fn merge_from(&mut self, other: Self) {
    15        crate::merge_strategies::list::atomic(&mut self.hosts, other.hosts);
    16        crate::DeepMerge::merge_from(&mut self.secret_name, other.secret_name);
    17    }
    18}
    19
    20impl<'de> crate::serde::Deserialize<'de> for IngressTLS {
    21    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    22        #[allow(non_camel_case_types)]
    23        enum Field {
    24            Key_hosts,
    25            Key_secret_name,
    26            Other,
    27        }
    28
    29        impl<'de> crate::serde::Deserialize<'de> for Field {
    30            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    31                struct Visitor;
    32
    33                impl crate::serde::de::Visitor<'_> for Visitor {
    34                    type Value = Field;
    35
    36                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    37                        f.write_str("field identifier")
    38                    }
    39
    40                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
    41                        Ok(match v {
    42                            "hosts" => Field::Key_hosts,
    43                            "secretName" => Field::Key_secret_name,
    44                            _ => Field::Other,
    45                        })
    46                    }
    47                }
    48
    49                deserializer.deserialize_identifier(Visitor)
    50            }
    51        }
    52
    53        struct Visitor;
    54
    55        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
    56            type Value = IngressTLS;
    57
    58            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    59                f.write_str("IngressTLS")
    60            }
    61
    62            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
    63                let mut value_hosts: Option<std::vec::Vec<std::string::String>> = None;
    64                let mut value_secret_name: Option<std::string::String> = None;
    65
    66                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
    67                    match key {
    68                        Field::Key_hosts => value_hosts = crate::serde::de::MapAccess::next_value(&mut map)?,
    69                        Field::Key_secret_name => value_secret_name = crate::serde::de::MapAccess::next_value(&mut map)?,
    70                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
    71                    }
    72                }
    73
    74                Ok(IngressTLS {
    75                    hosts: value_hosts,
    76                    secret_name: value_secret_name,
    77                })
    78            }
    79        }
    80
    81        deserializer.deserialize_struct(
    82            "IngressTLS",
    83            &[
    84                "hosts",
    85                "secretName",
    86            ],
    87            Visitor,
    88        )
    89    }
    90}
    91
    92impl crate::serde::Serialize for IngressTLS {
    93    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
    94        let mut state = serializer.serialize_struct(
    95            "IngressTLS",
    96            self.hosts.as_ref().map_or(0, |_| 1) +
    97            self.secret_name.as_ref().map_or(0, |_| 1),
    98        )?;
    99        if let Some(value) = &self.hosts {
    100            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "hosts", value)?;
    101        }
    102        if let Some(value) = &self.secret_name {
    103            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "secretName", value)?;
    104        }
    105        crate::serde::ser::SerializeStruct::end(state)
    106    }
    107}
    108
    109#[cfg(feature = "schemars")]
    110impl crate::schemars::JsonSchema for IngressTLS {
    111    fn schema_name() -> std::borrow::Cow<'static, str> {
    112        "io.k8s.api.networking.v1.IngressTLS".into()
    113    }
    114
    115    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
    116        crate::schemars::json_schema!({
    117            "description": "IngressTLS describes the transport layer security associated with an ingress.",
    118            "type": "object",
    119            "properties": {
    120                "hosts": {
    121                    "description": "hosts is a list of hosts included in the TLS certificate. The values in this list must match the name/s used in the tlsSecret. Defaults to the wildcard host setting for the loadbalancer controller fulfilling this Ingress, if left unspecified.",
    122                    "type": "array",
    123                    "items": {
    124                        "type": "string",
    125                    },
    126                },
    127                "secretName": {
    128                    "description": "secretName is the name of the secret used to terminate TLS traffic on port 443. Field is left optional to allow TLS routing based on SNI hostname alone. If the SNI host in a listener conflicts with the \"Host\" header field used by an IngressRule, the SNI host is used for termination and value of the \"Host\" header is used for routing.",
    129                    "type": "string",
    130                },
    131            },
    132        })
    133    }
    134}