openshift_openapi/v4_5/api/route/v1/
tls_config.rs

1// Generated from definition com.github.openshift.api.route.v1.TLSConfig
2
3/// TLSConfig defines config used to secure a route and provide termination
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct TLSConfig {
6    /// caCertificate provides the cert authority certificate contents
7    pub ca_certificate: Option<String>,
8
9    /// certificate provides certificate contents
10    pub certificate: Option<String>,
11
12    /// destinationCACertificate provides the contents of the ca certificate of the final destination.  When using reencrypt termination this file should be provided in order to have routers use it for health checks on the secure connection. If this field is not specified, the router may provide its own destination CA and perform hostname validation using the short service name (service.namespace.svc), which allows infrastructure generated certificates to automatically verify.
13    pub destination_ca_certificate: Option<String>,
14
15    /// insecureEdgeTerminationPolicy indicates the desired behavior for insecure connections to a route. While each router may make its own decisions on which ports to expose, this is normally port 80.
16    ///
17    /// * Allow - traffic is sent to the server on the insecure port (default) * Disable - no traffic is allowed on the insecure port. * Redirect - clients are redirected to the secure port.
18    pub insecure_edge_termination_policy: Option<String>,
19
20    /// key provides key file contents
21    pub key: Option<String>,
22
23    /// termination indicates termination type.
24    pub termination: String,
25}
26
27impl<'de> serde::Deserialize<'de> for TLSConfig {
28    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
29        #[allow(non_camel_case_types)]
30        enum Field {
31            Key_ca_certificate,
32            Key_certificate,
33            Key_destination_ca_certificate,
34            Key_insecure_edge_termination_policy,
35            Key_key,
36            Key_termination,
37            Other,
38        }
39
40        impl<'de> serde::Deserialize<'de> for Field {
41            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
42                struct Visitor;
43
44                impl<'de> serde::de::Visitor<'de> for Visitor {
45                    type Value = Field;
46
47                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
48                        f.write_str("field identifier")
49                    }
50
51                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
52                        Ok(match v {
53                            "caCertificate" => Field::Key_ca_certificate,
54                            "certificate" => Field::Key_certificate,
55                            "destinationCACertificate" => Field::Key_destination_ca_certificate,
56                            "insecureEdgeTerminationPolicy" => Field::Key_insecure_edge_termination_policy,
57                            "key" => Field::Key_key,
58                            "termination" => Field::Key_termination,
59                            _ => Field::Other,
60                        })
61                    }
62                }
63
64                deserializer.deserialize_identifier(Visitor)
65            }
66        }
67
68        struct Visitor;
69
70        impl<'de> serde::de::Visitor<'de> for Visitor {
71            type Value = TLSConfig;
72
73            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
74                f.write_str("TLSConfig")
75            }
76
77            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
78                let mut value_ca_certificate: Option<String> = None;
79                let mut value_certificate: Option<String> = None;
80                let mut value_destination_ca_certificate: Option<String> = None;
81                let mut value_insecure_edge_termination_policy: Option<String> = None;
82                let mut value_key: Option<String> = None;
83                let mut value_termination: Option<String> = None;
84
85                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
86                    match key {
87                        Field::Key_ca_certificate => value_ca_certificate = serde::de::MapAccess::next_value(&mut map)?,
88                        Field::Key_certificate => value_certificate = serde::de::MapAccess::next_value(&mut map)?,
89                        Field::Key_destination_ca_certificate => value_destination_ca_certificate = serde::de::MapAccess::next_value(&mut map)?,
90                        Field::Key_insecure_edge_termination_policy => value_insecure_edge_termination_policy = serde::de::MapAccess::next_value(&mut map)?,
91                        Field::Key_key => value_key = serde::de::MapAccess::next_value(&mut map)?,
92                        Field::Key_termination => value_termination = Some(serde::de::MapAccess::next_value(&mut map)?),
93                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
94                    }
95                }
96
97                Ok(TLSConfig {
98                    ca_certificate: value_ca_certificate,
99                    certificate: value_certificate,
100                    destination_ca_certificate: value_destination_ca_certificate,
101                    insecure_edge_termination_policy: value_insecure_edge_termination_policy,
102                    key: value_key,
103                    termination: value_termination.ok_or_else(|| serde::de::Error::missing_field("termination"))?,
104                })
105            }
106        }
107
108        deserializer.deserialize_struct(
109            "TLSConfig",
110            &[
111                "caCertificate",
112                "certificate",
113                "destinationCACertificate",
114                "insecureEdgeTerminationPolicy",
115                "key",
116                "termination",
117            ],
118            Visitor,
119        )
120    }
121}
122
123impl serde::Serialize for TLSConfig {
124    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
125        let mut state = serializer.serialize_struct(
126            "TLSConfig",
127            1 +
128            self.ca_certificate.as_ref().map_or(0, |_| 1) +
129            self.certificate.as_ref().map_or(0, |_| 1) +
130            self.destination_ca_certificate.as_ref().map_or(0, |_| 1) +
131            self.insecure_edge_termination_policy.as_ref().map_or(0, |_| 1) +
132            self.key.as_ref().map_or(0, |_| 1),
133        )?;
134        if let Some(value) = &self.ca_certificate {
135            serde::ser::SerializeStruct::serialize_field(&mut state, "caCertificate", value)?;
136        }
137        if let Some(value) = &self.certificate {
138            serde::ser::SerializeStruct::serialize_field(&mut state, "certificate", value)?;
139        }
140        if let Some(value) = &self.destination_ca_certificate {
141            serde::ser::SerializeStruct::serialize_field(&mut state, "destinationCACertificate", value)?;
142        }
143        if let Some(value) = &self.insecure_edge_termination_policy {
144            serde::ser::SerializeStruct::serialize_field(&mut state, "insecureEdgeTerminationPolicy", value)?;
145        }
146        if let Some(value) = &self.key {
147            serde::ser::SerializeStruct::serialize_field(&mut state, "key", value)?;
148        }
149        serde::ser::SerializeStruct::serialize_field(&mut state, "termination", &self.termination)?;
150        serde::ser::SerializeStruct::end(state)
151    }
152}
openshift_openapi/v4_5/api/route/v1/tls_config.rs

openshift_openapi/v4_5/api/route/v1/
tls_config.rs
