openshift_openapi/v4_5/api/authorization/v1/
cluster_role.rs

1// Generated from definition com.github.openshift.api.authorization.v1.ClusterRole
2
3/// ClusterRole is a logical grouping of PolicyRules that can be referenced as a unit by ClusterRoleBindings.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct ClusterRole {
6    /// AggregationRule is an optional field that describes how to build the Rules for this ClusterRole. If AggregationRule is set, then the Rules are controller managed and direct changes to Rules will be stomped by the controller.
7    pub aggregation_rule: Option<k8s_openapi::api::rbac::v1::AggregationRule>,
8
9    /// Standard object's metadata.
10    pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
11
12    /// Rules holds all the PolicyRules for this ClusterRole
13    pub rules: Vec<crate::api::authorization::v1::PolicyRule>,
14}
15
16// Begin authorization.openshift.io/v1/ClusterRole
17
18// Generated from operation createAuthorizationOpenshiftIoV1ClusterRole
19
20impl ClusterRole {
21    /// create a ClusterRole
22    ///
23    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
24    ///
25    /// # Arguments
26    ///
27    /// * `body`
28    ///
29    /// * `optional`
30    ///
31    ///     Optional parameters. Use `Default::default()` to not pass any.
32    #[cfg(feature = "api")]
33    pub fn create_cluster_role(
34        body: &crate::api::authorization::v1::ClusterRole,
35        optional: k8s_openapi::CreateOptional<'_>,
36    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
37        let __url = "/apis/authorization.openshift.io/v1/clusterroles?".to_owned();
38        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
39        optional.__serialize(&mut __query_pairs);
40        let __url = __query_pairs.finish();
41
42        let __request = http::Request::post(__url);
43        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
44        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
45        match __request.body(__body) {
46            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
47            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
48        }
49    }
50}
51
52// Generated from operation deleteAuthorizationOpenshiftIoV1ClusterRole
53
54impl ClusterRole {
55    /// delete a ClusterRole
56    ///
57    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::DeleteResponse`]`<Self>>` constructor, or [`k8s_openapi::DeleteResponse`]`<Self>` directly, to parse the HTTP response.
58    ///
59    /// # Arguments
60    ///
61    /// * `name`
62    ///
63    ///     name of the ClusterRole
64    ///
65    /// * `optional`
66    ///
67    ///     Optional parameters. Use `Default::default()` to not pass any.
68    #[cfg(feature = "api")]
69    pub fn delete_cluster_role(
70        name: &str,
71        optional: k8s_openapi::DeleteOptional<'_>,
72    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::DeleteResponse<Self>>), k8s_openapi::RequestError> {
73        let __url = format!("/apis/authorization.openshift.io/v1/clusterroles/{name}",
74            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
75        );
76
77        let __request = http::Request::delete(__url);
78        let __body = serde_json::to_vec(&optional).map_err(k8s_openapi::RequestError::Json)?;
79        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
80        match __request.body(__body) {
81            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
82            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
83        }
84    }
85}
86
87// Generated from operation listAuthorizationOpenshiftIoV1ClusterRole
88
89impl ClusterRole {
90    /// list objects of kind ClusterRole
91    ///
92    /// This operation only supports listing all items of this type.
93    ///
94    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ListResponse`]`<Self>>` constructor, or [`k8s_openapi::ListResponse`]`<Self>` directly, to parse the HTTP response.
95    ///
96    /// # Arguments
97    ///
98    /// * `optional`
99    ///
100    ///     Optional parameters. Use `Default::default()` to not pass any.
101    #[cfg(feature = "api")]
102    pub fn list_cluster_role(
103        optional: k8s_openapi::ListOptional<'_>,
104    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ListResponse<Self>>), k8s_openapi::RequestError> {
105        let __url = "/apis/authorization.openshift.io/v1/clusterroles?".to_owned();
106        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
107        optional.__serialize(&mut __query_pairs);
108        let __url = __query_pairs.finish();
109
110        let __request = http::Request::get(__url);
111        let __body = vec![];
112        match __request.body(__body) {
113            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
114            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
115        }
116    }
117}
118
119// Generated from operation patchAuthorizationOpenshiftIoV1ClusterRole
120
121impl ClusterRole {
122    /// partially update the specified ClusterRole
123    ///
124    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::PatchResponse`]`<Self>>` constructor, or [`k8s_openapi::PatchResponse`]`<Self>` directly, to parse the HTTP response.
125    ///
126    /// # Arguments
127    ///
128    /// * `name`
129    ///
130    ///     name of the ClusterRole
131    ///
132    /// * `body`
133    ///
134    /// * `optional`
135    ///
136    ///     Optional parameters. Use `Default::default()` to not pass any.
137    #[cfg(feature = "api")]
138    pub fn patch_cluster_role(
139        name: &str,
140        body: &k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch,
141        optional: k8s_openapi::PatchOptional<'_>,
142    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::PatchResponse<Self>>), k8s_openapi::RequestError> {
143        let __url = format!("/apis/authorization.openshift.io/v1/clusterroles/{name}?",
144            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
145        );
146        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
147        optional.__serialize(&mut __query_pairs);
148        let __url = __query_pairs.finish();
149
150        let __request = http::Request::patch(__url);
151        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
152        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static(match body {
153            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Json(_) => "application/json-patch+json",
154            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Merge(_) => "application/merge-patch+json",
155            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::StrategicMerge(_) => "application/strategic-merge-patch+json",
156        }));
157        match __request.body(__body) {
158            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
159            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
160        }
161    }
162}
163
164// Generated from operation readAuthorizationOpenshiftIoV1ClusterRole
165
166impl ClusterRole {
167    /// read the specified ClusterRole
168    ///
169    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`ReadClusterRoleResponse`]`>` constructor, or [`ReadClusterRoleResponse`] directly, to parse the HTTP response.
170    ///
171    /// # Arguments
172    ///
173    /// * `name`
174    ///
175    ///     name of the ClusterRole
176    ///
177    /// * `optional`
178    ///
179    ///     Optional parameters. Use `Default::default()` to not pass any.
180    #[cfg(feature = "api")]
181    pub fn read_cluster_role(
182        name: &str,
183        optional: ReadClusterRoleOptional<'_>,
184    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<ReadClusterRoleResponse>), k8s_openapi::RequestError> {
185        let ReadClusterRoleOptional {
186            pretty,
187        } = optional;
188        let __url = format!("/apis/authorization.openshift.io/v1/clusterroles/{name}?",
189            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
190        );
191        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
192        if let Some(pretty) = pretty {
193            __query_pairs.append_pair("pretty", pretty);
194        }
195        let __url = __query_pairs.finish();
196
197        let __request = http::Request::get(__url);
198        let __body = vec![];
199        match __request.body(__body) {
200            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
201            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
202        }
203    }
204}
205
206/// Optional parameters of [`ClusterRole::read_cluster_role`]
207#[cfg(feature = "api")]
208#[derive(Clone, Copy, Debug, Default)]
209pub struct ReadClusterRoleOptional<'a> {
210    /// If 'true', then the output is pretty printed.
211    pub pretty: Option<&'a str>,
212}
213
214/// Use `<ReadClusterRoleResponse as Response>::try_from_parts` to parse the HTTP response body of [`ClusterRole::read_cluster_role`]
215#[cfg(feature = "api")]
216#[derive(Debug)]
217pub enum ReadClusterRoleResponse {
218    Ok(crate::api::authorization::v1::ClusterRole),
219    Other(Result<Option<serde_json::Value>, serde_json::Error>),
220}
221
222#[cfg(feature = "api")]
223impl k8s_openapi::Response for ReadClusterRoleResponse {
224    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
225        match status_code {
226            http::StatusCode::OK => {
227                let result = match serde_json::from_slice(buf) {
228                    Ok(value) => value,
229                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
230                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
231                };
232                Ok((ReadClusterRoleResponse::Ok(result), buf.len()))
233            },
234            _ => {
235                let (result, read) =
236                    if buf.is_empty() {
237                        (Ok(None), 0)
238                    }
239                    else {
240                        match serde_json::from_slice(buf) {
241                            Ok(value) => (Ok(Some(value)), buf.len()),
242                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
243                            Err(err) => (Err(err), 0),
244                        }
245                    };
246                Ok((ReadClusterRoleResponse::Other(result), read))
247            },
248        }
249    }
250}
251
252// Generated from operation replaceAuthorizationOpenshiftIoV1ClusterRole
253
254impl ClusterRole {
255    /// replace the specified ClusterRole
256    ///
257    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ReplaceResponse`]`<Self>>` constructor, or [`k8s_openapi::ReplaceResponse`]`<Self>` directly, to parse the HTTP response.
258    ///
259    /// # Arguments
260    ///
261    /// * `name`
262    ///
263    ///     name of the ClusterRole
264    ///
265    /// * `body`
266    ///
267    /// * `optional`
268    ///
269    ///     Optional parameters. Use `Default::default()` to not pass any.
270    #[cfg(feature = "api")]
271    pub fn replace_cluster_role(
272        name: &str,
273        body: &crate::api::authorization::v1::ClusterRole,
274        optional: k8s_openapi::ReplaceOptional<'_>,
275    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ReplaceResponse<Self>>), k8s_openapi::RequestError> {
276        let __url = format!("/apis/authorization.openshift.io/v1/clusterroles/{name}?",
277            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
278        );
279        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
280        optional.__serialize(&mut __query_pairs);
281        let __url = __query_pairs.finish();
282
283        let __request = http::Request::put(__url);
284        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
285        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
286        match __request.body(__body) {
287            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
288            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
289        }
290    }
291}
292
293// Generated from operation watchAuthorizationOpenshiftIoV1ClusterRole
294
295impl ClusterRole {
296    /// list objects of kind ClusterRole
297    ///
298    /// This operation only supports watching one item, or a list of items, of this type for changes.
299    ///
300    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::WatchResponse`]`<Self>>` constructor, or [`k8s_openapi::WatchResponse`]`<Self>` directly, to parse the HTTP response.
301    ///
302    /// # Arguments
303    ///
304    /// * `optional`
305    ///
306    ///     Optional parameters. Use `Default::default()` to not pass any.
307    #[cfg(feature = "api")]
308    pub fn watch_cluster_role(
309        optional: k8s_openapi::WatchOptional<'_>,
310    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::WatchResponse<Self>>), k8s_openapi::RequestError> {
311        let __url = "/apis/authorization.openshift.io/v1/clusterroles?".to_owned();
312        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
313        optional.__serialize(&mut __query_pairs);
314        let __url = __query_pairs.finish();
315
316        let __request = http::Request::get(__url);
317        let __body = vec![];
318        match __request.body(__body) {
319            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
320            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
321        }
322    }
323}
324
325// End authorization.openshift.io/v1/ClusterRole
326
327impl k8s_openapi::Resource for ClusterRole {
328    const API_VERSION: &'static str = "authorization.openshift.io/v1";
329    const GROUP: &'static str = "authorization.openshift.io";
330    const KIND: &'static str = "ClusterRole";
331    const VERSION: &'static str = "v1";
332}
333
334impl k8s_openapi::ListableResource for ClusterRole {
335    const LIST_KIND: &'static str = concat!("ClusterRole", "List");
336}
337
338impl k8s_openapi::Metadata for ClusterRole {
339    type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
340
341    fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
342        &self.metadata
343    }
344
345    fn metadata_mut(&mut self) -> &mut<Self as k8s_openapi::Metadata>::Ty {
346        &mut self.metadata
347    }
348}
349
350impl<'de> serde::Deserialize<'de> for ClusterRole {
351    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
352        #[allow(non_camel_case_types)]
353        enum Field {
354            Key_api_version,
355            Key_kind,
356            Key_aggregation_rule,
357            Key_metadata,
358            Key_rules,
359            Other,
360        }
361
362        impl<'de> serde::Deserialize<'de> for Field {
363            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
364                struct Visitor;
365
366                impl<'de> serde::de::Visitor<'de> for Visitor {
367                    type Value = Field;
368
369                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
370                        f.write_str("field identifier")
371                    }
372
373                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
374                        Ok(match v {
375                            "apiVersion" => Field::Key_api_version,
376                            "kind" => Field::Key_kind,
377                            "aggregationRule" => Field::Key_aggregation_rule,
378                            "metadata" => Field::Key_metadata,
379                            "rules" => Field::Key_rules,
380                            _ => Field::Other,
381                        })
382                    }
383                }
384
385                deserializer.deserialize_identifier(Visitor)
386            }
387        }
388
389        struct Visitor;
390
391        impl<'de> serde::de::Visitor<'de> for Visitor {
392            type Value = ClusterRole;
393
394            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
395                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
396            }
397
398            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
399                let mut value_aggregation_rule: Option<k8s_openapi::api::rbac::v1::AggregationRule> = None;
400                let mut value_metadata: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
401                let mut value_rules: Option<Vec<crate::api::authorization::v1::PolicyRule>> = None;
402
403                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
404                    match key {
405                        Field::Key_api_version => {
406                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
407                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
408                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
409                            }
410                        },
411                        Field::Key_kind => {
412                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
413                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
414                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
415                            }
416                        },
417                        Field::Key_aggregation_rule => value_aggregation_rule = serde::de::MapAccess::next_value(&mut map)?,
418                        Field::Key_metadata => value_metadata = Some(serde::de::MapAccess::next_value(&mut map)?),
419                        Field::Key_rules => value_rules = Some(serde::de::MapAccess::next_value(&mut map)?),
420                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
421                    }
422                }
423
424                Ok(ClusterRole {
425                    aggregation_rule: value_aggregation_rule,
426                    metadata: value_metadata.ok_or_else(|| serde::de::Error::missing_field("metadata"))?,
427                    rules: value_rules.ok_or_else(|| serde::de::Error::missing_field("rules"))?,
428                })
429            }
430        }
431
432        deserializer.deserialize_struct(
433            <Self as k8s_openapi::Resource>::KIND,
434            &[
435                "apiVersion",
436                "kind",
437                "aggregationRule",
438                "metadata",
439                "rules",
440            ],
441            Visitor,
442        )
443    }
444}
445
446impl serde::Serialize for ClusterRole {
447    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
448        let mut state = serializer.serialize_struct(
449            <Self as k8s_openapi::Resource>::KIND,
450            4 +
451            self.aggregation_rule.as_ref().map_or(0, |_| 1),
452        )?;
453        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
454        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
455        if let Some(value) = &self.aggregation_rule {
456            serde::ser::SerializeStruct::serialize_field(&mut state, "aggregationRule", value)?;
457        }
458        serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
459        serde::ser::SerializeStruct::serialize_field(&mut state, "rules", &self.rules)?;
460        serde::ser::SerializeStruct::end(state)
461    }
462}
openshift_openapi/v4_5/api/authorization/v1/cluster_role.rs

openshift_openapi/v4_5/api/authorization/v1/
cluster_role.rs
