k8s_openapi/v1_35/api/core/v1/
file_key_selector.rs1#[derive(Clone, Debug, Default, PartialEq)]
5pub struct FileKeySelector {
6 pub key: std::string::String,
8
9 pub optional: Option<bool>,
13
14 pub path: std::string::String,
16
17 pub volume_name: std::string::String,
19}
20
21impl crate::DeepMerge for FileKeySelector {
22 fn merge_from(&mut self, other: Self) {
23 crate::DeepMerge::merge_from(&mut self.key, other.key);
24 crate::DeepMerge::merge_from(&mut self.optional, other.optional);
25 crate::DeepMerge::merge_from(&mut self.path, other.path);
26 crate::DeepMerge::merge_from(&mut self.volume_name, other.volume_name);
27 }
28}
29
30impl<'de> crate::serde::Deserialize<'de> for FileKeySelector {
31 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
32 #[allow(non_camel_case_types)]
33 enum Field {
34 Key_key,
35 Key_optional,
36 Key_path,
37 Key_volume_name,
38 Other,
39 }
40
41 impl<'de> crate::serde::Deserialize<'de> for Field {
42 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
43 struct Visitor;
44
45 impl crate::serde::de::Visitor<'_> for Visitor {
46 type Value = Field;
47
48 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
49 f.write_str("field identifier")
50 }
51
52 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
53 Ok(match v {
54 "key" => Field::Key_key,
55 "optional" => Field::Key_optional,
56 "path" => Field::Key_path,
57 "volumeName" => Field::Key_volume_name,
58 _ => Field::Other,
59 })
60 }
61 }
62
63 deserializer.deserialize_identifier(Visitor)
64 }
65 }
66
67 struct Visitor;
68
69 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
70 type Value = FileKeySelector;
71
72 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
73 f.write_str("FileKeySelector")
74 }
75
76 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
77 let mut value_key: Option<std::string::String> = None;
78 let mut value_optional: Option<bool> = None;
79 let mut value_path: Option<std::string::String> = None;
80 let mut value_volume_name: Option<std::string::String> = None;
81
82 while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
83 match key {
84 Field::Key_key => value_key = crate::serde::de::MapAccess::next_value(&mut map)?,
85 Field::Key_optional => value_optional = crate::serde::de::MapAccess::next_value(&mut map)?,
86 Field::Key_path => value_path = crate::serde::de::MapAccess::next_value(&mut map)?,
87 Field::Key_volume_name => value_volume_name = crate::serde::de::MapAccess::next_value(&mut map)?,
88 Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
89 }
90 }
91
92 Ok(FileKeySelector {
93 key: value_key.unwrap_or_default(),
94 optional: value_optional,
95 path: value_path.unwrap_or_default(),
96 volume_name: value_volume_name.unwrap_or_default(),
97 })
98 }
99 }
100
101 deserializer.deserialize_struct(
102 "FileKeySelector",
103 &[
104 "key",
105 "optional",
106 "path",
107 "volumeName",
108 ],
109 Visitor,
110 )
111 }
112}
113
114impl crate::serde::Serialize for FileKeySelector {
115 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
116 let mut state = serializer.serialize_struct(
117 "FileKeySelector",
118 3 +
119 self.optional.as_ref().map_or(0, |_| 1),
120 )?;
121 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "key", &self.key)?;
122 if let Some(value) = &self.optional {
123 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "optional", value)?;
124 }
125 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "path", &self.path)?;
126 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "volumeName", &self.volume_name)?;
127 crate::serde::ser::SerializeStruct::end(state)
128 }
129}
130
131#[cfg(feature = "schemars")]
132impl crate::schemars::JsonSchema for FileKeySelector {
133 fn schema_name() -> std::borrow::Cow<'static, str> {
134 "io.k8s.api.core.v1.FileKeySelector".into()
135 }
136
137 fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
138 crate::schemars::json_schema!({
139 "description": "FileKeySelector selects a key of the env file.",
140 "type": "object",
141 "properties": {
142 "key": {
143 "description": "The key within the env file. An invalid key will prevent the pod from starting. The keys defined within a source may consist of any printable ASCII characters except '='. During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.",
144 "type": "string",
145 },
146 "optional": {
147 "description": "Specify whether the file or its key must be defined. If the file or key does not exist, then the env var is not published. If optional is set to true and the specified key does not exist, the environment variable will not be set in the Pod's containers.\n\nIf optional is set to false and the specified key does not exist, an error will be returned during Pod creation.",
148 "type": "boolean",
149 },
150 "path": {
151 "description": "The path within the volume from which to select the file. Must be relative and may not contain the '..' path or start with '..'.",
152 "type": "string",
153 },
154 "volumeName": {
155 "description": "The name of the volume mount containing the env file.",
156 "type": "string",
157 },
158 },
159 "required": [
160 "key",
161 "path",
162 "volumeName",
163 ],
164 })
165 }
166}