k8s_openapi/v1_37/api/apiserverinternal/v1alpha1/
server_storage_version.rs

1// Generated from definition io.k8s.api.apiserverinternal.v1alpha1.ServerStorageVersion
2
3/// An API server instance reports the version it can decode and the version it encodes objects to when persisting objects in the backend.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct ServerStorageVersion {
6    /// apiServerID is the ID of the reporting API server.
7    pub api_server_id: std::string::String,
8
9    /// decodableVersions are the encoding versions the API server can handle to decode. The API server can decode objects encoded in these versions. The encodingVersion must be included in the decodableVersions.
10    pub decodable_versions: std::vec::Vec<std::string::String>,
11
12    /// encodingVersion the API server encodes the object to when persisting it in the backend (e.g., etcd).
13    pub encoding_version: std::string::String,
14
15    /// servedVersions lists all versions the API server can serve. DecodableVersions must include all ServedVersions.
16    pub served_versions: Option<std::vec::Vec<std::string::String>>,
17}
18
19impl crate::DeepMerge for ServerStorageVersion {
20    fn merge_from(&mut self, other: Self) {
21        crate::DeepMerge::merge_from(&mut self.api_server_id, other.api_server_id);
22        crate::merge_strategies::list::set(&mut self.decodable_versions, other.decodable_versions);
23        crate::DeepMerge::merge_from(&mut self.encoding_version, other.encoding_version);
24        crate::merge_strategies::list::set(&mut self.served_versions, other.served_versions);
25    }
26}
27
28impl<'de> crate::serde::Deserialize<'de> for ServerStorageVersion {
29    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
30        #[allow(non_camel_case_types)]
31        enum Field {
32            Key_api_server_id,
33            Key_decodable_versions,
34            Key_encoding_version,
35            Key_served_versions,
36            Other,
37        }
38
39        impl<'de> crate::serde::Deserialize<'de> for Field {
40            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
41                struct Visitor;
42
43                impl crate::serde::de::Visitor<'_> for Visitor {
44                    type Value = Field;
45
46                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
47                        f.write_str("field identifier")
48                    }
49
50                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
51                        Ok(match v {
52                            "apiServerID" => Field::Key_api_server_id,
53                            "decodableVersions" => Field::Key_decodable_versions,
54                            "encodingVersion" => Field::Key_encoding_version,
55                            "servedVersions" => Field::Key_served_versions,
56                            _ => Field::Other,
57                        })
58                    }
59                }
60
61                deserializer.deserialize_identifier(Visitor)
62            }
63        }
64
65        struct Visitor;
66
67        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
68            type Value = ServerStorageVersion;
69
70            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
71                f.write_str("ServerStorageVersion")
72            }
73
74            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
75                let mut value_api_server_id: Option<std::string::String> = None;
76                let mut value_decodable_versions: Option<std::vec::Vec<std::string::String>> = None;
77                let mut value_encoding_version: Option<std::string::String> = None;
78                let mut value_served_versions: Option<std::vec::Vec<std::string::String>> = None;
79
80                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
81                    match key {
82                        Field::Key_api_server_id => value_api_server_id = crate::serde::de::MapAccess::next_value(&mut map)?,
83                        Field::Key_decodable_versions => value_decodable_versions = crate::serde::de::MapAccess::next_value(&mut map)?,
84                        Field::Key_encoding_version => value_encoding_version = crate::serde::de::MapAccess::next_value(&mut map)?,
85                        Field::Key_served_versions => value_served_versions = crate::serde::de::MapAccess::next_value(&mut map)?,
86                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
87                    }
88                }
89
90                Ok(ServerStorageVersion {
91                    api_server_id: value_api_server_id.unwrap_or_default(),
92                    decodable_versions: value_decodable_versions.unwrap_or_default(),
93                    encoding_version: value_encoding_version.unwrap_or_default(),
94                    served_versions: value_served_versions,
95                })
96            }
97        }
98
99        deserializer.deserialize_struct(
100            "ServerStorageVersion",
101            &[
102                "apiServerID",
103                "decodableVersions",
104                "encodingVersion",
105                "servedVersions",
106            ],
107            Visitor,
108        )
109    }
110}
111
112impl crate::serde::Serialize for ServerStorageVersion {
113    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
114        let mut state = serializer.serialize_struct(
115            "ServerStorageVersion",
116            3 +
117            self.served_versions.as_ref().map_or(0, |_| 1),
118        )?;
119        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "apiServerID", &self.api_server_id)?;
120        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "decodableVersions", &self.decodable_versions)?;
121        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "encodingVersion", &self.encoding_version)?;
122        if let Some(value) = &self.served_versions {
123            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "servedVersions", value)?;
124        }
125        crate::serde::ser::SerializeStruct::end(state)
126    }
127}
128
129#[cfg(feature = "schemars")]
130impl crate::schemars::JsonSchema for ServerStorageVersion {
131    fn schema_name() -> std::borrow::Cow<'static, str> {
132        "io.k8s.api.apiserverinternal.v1alpha1.ServerStorageVersion".into()
133    }
134
135    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
136        crate::schemars::json_schema!({
137            "description": "An API server instance reports the version it can decode and the version it encodes objects to when persisting objects in the backend.",
138            "type": "object",
139            "properties": {
140                "apiServerID": {
141                    "description": "apiServerID is the ID of the reporting API server.",
142                    "type": "string",
143                },
144                "decodableVersions": {
145                    "description": "decodableVersions are the encoding versions the API server can handle to decode. The API server can decode objects encoded in these versions. The encodingVersion must be included in the decodableVersions.",
146                    "type": "array",
147                    "items": {
148                        "type": "string",
149                    },
150                },
151                "encodingVersion": {
152                    "description": "encodingVersion the API server encodes the object to when persisting it in the backend (e.g., etcd).",
153                    "type": "string",
154                },
155                "servedVersions": {
156                    "description": "servedVersions lists all versions the API server can serve. DecodableVersions must include all ServedVersions.",
157                    "type": "array",
158                    "items": {
159                        "type": "string",
160                    },
161                },
162            },
163            "required": [
164                "apiServerID",
165                "decodableVersions",
166                "encodingVersion",
167            ],
168        })
169    }
170}
k8s_openapi/v1_37/api/apiserverinternal/v1alpha1/server_storage_version.rs

k8s_openapi/v1_37/api/apiserverinternal/v1alpha1/
server_storage_version.rs
