k8s_openapi/v1_33/api/resource/v1alpha3/
device_taint_rule.rs

1// Generated from definition io.k8s.api.resource.v1alpha3.DeviceTaintRule
2
3/// DeviceTaintRule adds one taint to all devices which match the selector. This has the same effect as if the taint was specified directly in the ResourceSlice by the DRA driver.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct DeviceTaintRule {
6    /// Standard object metadata
7    pub metadata: crate::apimachinery::pkg::apis::meta::v1::ObjectMeta,
8
9    /// Spec specifies the selector and one taint.
10    ///
11    /// Changing the spec automatically increments the metadata.generation number.
12    pub spec: crate::api::resource::v1alpha3::DeviceTaintRuleSpec,
13}
14
15impl crate::Resource for DeviceTaintRule {
16    const API_VERSION: &'static str = "resource.k8s.io/v1alpha3";
17    const GROUP: &'static str = "resource.k8s.io";
18    const KIND: &'static str = "DeviceTaintRule";
19    const VERSION: &'static str = "v1alpha3";
20    const URL_PATH_SEGMENT: &'static str = "devicetaintrules";
21    type Scope = crate::ClusterResourceScope;
22}
23
24impl crate::ListableResource for DeviceTaintRule {
25    const LIST_KIND: &'static str = "DeviceTaintRuleList";
26}
27
28impl crate::Metadata for DeviceTaintRule {
29    type Ty = crate::apimachinery::pkg::apis::meta::v1::ObjectMeta;
30
31    fn metadata(&self) -> &<Self as crate::Metadata>::Ty {
32        &self.metadata
33    }
34
35    fn metadata_mut(&mut self) -> &mut<Self as crate::Metadata>::Ty {
36        &mut self.metadata
37    }
38}
39
40impl crate::DeepMerge for DeviceTaintRule {
41    fn merge_from(&mut self, other: Self) {
42        crate::DeepMerge::merge_from(&mut self.metadata, other.metadata);
43        crate::DeepMerge::merge_from(&mut self.spec, other.spec);
44    }
45}
46
47impl<'de> crate::serde::Deserialize<'de> for DeviceTaintRule {
48    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
49        #[allow(non_camel_case_types)]
50        enum Field {
51            Key_api_version,
52            Key_kind,
53            Key_metadata,
54            Key_spec,
55            Other,
56        }
57
58        impl<'de> crate::serde::Deserialize<'de> for Field {
59            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
60                struct Visitor;
61
62                impl crate::serde::de::Visitor<'_> for Visitor {
63                    type Value = Field;
64
65                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
66                        f.write_str("field identifier")
67                    }
68
69                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
70                        Ok(match v {
71                            "apiVersion" => Field::Key_api_version,
72                            "kind" => Field::Key_kind,
73                            "metadata" => Field::Key_metadata,
74                            "spec" => Field::Key_spec,
75                            _ => Field::Other,
76                        })
77                    }
78                }
79
80                deserializer.deserialize_identifier(Visitor)
81            }
82        }
83
84        struct Visitor;
85
86        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
87            type Value = DeviceTaintRule;
88
89            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
90                f.write_str(<Self::Value as crate::Resource>::KIND)
91            }
92
93            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
94                let mut value_metadata: Option<crate::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
95                let mut value_spec: Option<crate::api::resource::v1alpha3::DeviceTaintRuleSpec> = None;
96
97                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
98                    match key {
99                        Field::Key_api_version => {
100                            let value_api_version: std::string::String = crate::serde::de::MapAccess::next_value(&mut map)?;
101                            if value_api_version != <Self::Value as crate::Resource>::API_VERSION {
102                                return Err(crate::serde::de::Error::invalid_value(crate::serde::de::Unexpected::Str(&value_api_version), &<Self::Value as crate::Resource>::API_VERSION));
103                            }
104                        },
105                        Field::Key_kind => {
106                            let value_kind: std::string::String = crate::serde::de::MapAccess::next_value(&mut map)?;
107                            if value_kind != <Self::Value as crate::Resource>::KIND {
108                                return Err(crate::serde::de::Error::invalid_value(crate::serde::de::Unexpected::Str(&value_kind), &<Self::Value as crate::Resource>::KIND));
109                            }
110                        },
111                        Field::Key_metadata => value_metadata = crate::serde::de::MapAccess::next_value(&mut map)?,
112                        Field::Key_spec => value_spec = crate::serde::de::MapAccess::next_value(&mut map)?,
113                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
114                    }
115                }
116
117                Ok(DeviceTaintRule {
118                    metadata: value_metadata.unwrap_or_default(),
119                    spec: value_spec.unwrap_or_default(),
120                })
121            }
122        }
123
124        deserializer.deserialize_struct(
125            <Self as crate::Resource>::KIND,
126            &[
127                "apiVersion",
128                "kind",
129                "metadata",
130                "spec",
131            ],
132            Visitor,
133        )
134    }
135}
136
137impl crate::serde::Serialize for DeviceTaintRule {
138    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
139        let mut state = serializer.serialize_struct(
140            <Self as crate::Resource>::KIND,
141            4,
142        )?;
143        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as crate::Resource>::API_VERSION)?;
144        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as crate::Resource>::KIND)?;
145        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
146        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "spec", &self.spec)?;
147        crate::serde::ser::SerializeStruct::end(state)
148    }
149}
150
151#[cfg(feature = "schemars")]
152impl crate::schemars::JsonSchema for DeviceTaintRule {
153    fn schema_name() -> std::string::String {
154        "io.k8s.api.resource.v1alpha3.DeviceTaintRule".into()
155    }
156
157    fn json_schema(__gen: &mut crate::schemars::gen::SchemaGenerator) -> crate::schemars::schema::Schema {
158        crate::schemars::schema::Schema::Object(crate::schemars::schema::SchemaObject {
159            metadata: Some(std::boxed::Box::new(crate::schemars::schema::Metadata {
160                description: Some("DeviceTaintRule adds one taint to all devices which match the selector. This has the same effect as if the taint was specified directly in the ResourceSlice by the DRA driver.".into()),
161                ..Default::default()
162            })),
163            instance_type: Some(crate::schemars::schema::SingleOrVec::Single(std::boxed::Box::new(crate::schemars::schema::InstanceType::Object))),
164            object: Some(std::boxed::Box::new(crate::schemars::schema::ObjectValidation {
165                properties: [
166                    (
167                        "apiVersion".into(),
168                        crate::schemars::schema::Schema::Object(crate::schemars::schema::SchemaObject {
169                            metadata: Some(std::boxed::Box::new(crate::schemars::schema::Metadata {
170                                description: Some("APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources".into()),
171                                ..Default::default()
172                            })),
173                            instance_type: Some(crate::schemars::schema::SingleOrVec::Single(std::boxed::Box::new(crate::schemars::schema::InstanceType::String))),
174                            ..Default::default()
175                        }),
176                    ),
177                    (
178                        "kind".into(),
179                        crate::schemars::schema::Schema::Object(crate::schemars::schema::SchemaObject {
180                            metadata: Some(std::boxed::Box::new(crate::schemars::schema::Metadata {
181                                description: Some("Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds".into()),
182                                ..Default::default()
183                            })),
184                            instance_type: Some(crate::schemars::schema::SingleOrVec::Single(std::boxed::Box::new(crate::schemars::schema::InstanceType::String))),
185                            ..Default::default()
186                        }),
187                    ),
188                    (
189                        "metadata".into(),
190                        {
191                            let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::ObjectMeta>().into_object();
192                            schema_obj.metadata = Some(std::boxed::Box::new(crate::schemars::schema::Metadata {
193                                description: Some("Standard object metadata".into()),
194                                ..Default::default()
195                            }));
196                            crate::schemars::schema::Schema::Object(schema_obj)
197                        },
198                    ),
199                    (
200                        "spec".into(),
201                        {
202                            let mut schema_obj = __gen.subschema_for::<crate::api::resource::v1alpha3::DeviceTaintRuleSpec>().into_object();
203                            schema_obj.metadata = Some(std::boxed::Box::new(crate::schemars::schema::Metadata {
204                                description: Some("Spec specifies the selector and one taint.\n\nChanging the spec automatically increments the metadata.generation number.".into()),
205                                ..Default::default()
206                            }));
207                            crate::schemars::schema::Schema::Object(schema_obj)
208                        },
209                    ),
210                ].into(),
211                required: [
212                    "metadata".into(),
213                    "spec".into(),
214                ].into(),
215                ..Default::default()
216            })),
217            ..Default::default()
218        })
219    }
220}