#
k8s_openapi/v1_35/api/core/v1/
secret_env_source.rs

    1// Generated from definition io.k8s.api.core.v1.SecretEnvSource
    2
    3/// SecretEnvSource selects a Secret to populate the environment variables with.
    4///
    5/// The contents of the target Secret's Data field will represent the key-value pairs as environment variables.
    6#[derive(Clone, Debug, Default, PartialEq)]
    7pub struct SecretEnvSource {
    8    /// Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
    9    pub name: std::string::String,
    10
    11    /// Specify whether the Secret must be defined
    12    pub optional: Option<bool>,
    13}
    14
    15impl crate::DeepMerge for SecretEnvSource {
    16    fn merge_from(&mut self, other: Self) {
    17        crate::DeepMerge::merge_from(&mut self.name, other.name);
    18        crate::DeepMerge::merge_from(&mut self.optional, other.optional);
    19    }
    20}
    21
    22impl<'de> crate::serde::Deserialize<'de> for SecretEnvSource {
    23    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    24        #[allow(non_camel_case_types)]
    25        enum Field {
    26            Key_name,
    27            Key_optional,
    28            Other,
    29        }
    30
    31        impl<'de> crate::serde::Deserialize<'de> for Field {
    32            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    33                struct Visitor;
    34
    35                impl crate::serde::de::Visitor<'_> for Visitor {
    36                    type Value = Field;
    37
    38                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    39                        f.write_str("field identifier")
    40                    }
    41
    42                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
    43                        Ok(match v {
    44                            "name" => Field::Key_name,
    45                            "optional" => Field::Key_optional,
    46                            _ => Field::Other,
    47                        })
    48                    }
    49                }
    50
    51                deserializer.deserialize_identifier(Visitor)
    52            }
    53        }
    54
    55        struct Visitor;
    56
    57        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
    58            type Value = SecretEnvSource;
    59
    60            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    61                f.write_str("SecretEnvSource")
    62            }
    63
    64            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
    65                let mut value_name: Option<std::string::String> = None;
    66                let mut value_optional: Option<bool> = None;
    67
    68                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
    69                    match key {
    70                        Field::Key_name => value_name = crate::serde::de::MapAccess::next_value(&mut map)?,
    71                        Field::Key_optional => value_optional = crate::serde::de::MapAccess::next_value(&mut map)?,
    72                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
    73                    }
    74                }
    75
    76                Ok(SecretEnvSource {
    77                    name: value_name.unwrap_or_default(),
    78                    optional: value_optional,
    79                })
    80            }
    81        }
    82
    83        deserializer.deserialize_struct(
    84            "SecretEnvSource",
    85            &[
    86                "name",
    87                "optional",
    88            ],
    89            Visitor,
    90        )
    91    }
    92}
    93
    94impl crate::serde::Serialize for SecretEnvSource {
    95    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
    96        let mut state = serializer.serialize_struct(
    97            "SecretEnvSource",
    98            1 +
    99            self.optional.as_ref().map_or(0, |_| 1),
    100        )?;
    101        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "name", &self.name)?;
    102        if let Some(value) = &self.optional {
    103            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "optional", value)?;
    104        }
    105        crate::serde::ser::SerializeStruct::end(state)
    106    }
    107}
    108
    109#[cfg(feature = "schemars")]
    110impl crate::schemars::JsonSchema for SecretEnvSource {
    111    fn schema_name() -> std::borrow::Cow<'static, str> {
    112        "io.k8s.api.core.v1.SecretEnvSource".into()
    113    }
    114
    115    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
    116        crate::schemars::json_schema!({
    117            "description": "SecretEnvSource selects a Secret to populate the environment variables with.\n\nThe contents of the target Secret's Data field will represent the key-value pairs as environment variables.",
    118            "type": "object",
    119            "properties": {
    120                "name": {
    121                    "description": "Name of the referent. This field is effectively required, but due to backwards compatibility is allowed to be empty. Instances of this type with an empty value here are almost certainly wrong. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
    122                    "type": "string",
    123                },
    124                "optional": {
    125                    "description": "Specify whether the Secret must be defined",
    126                    "type": "boolean",
    127                },
    128            },
    129            "required": [
    130                "name",
    131            ],
    132        })
    133    }
    134}