openshift_openapi/v4_5/api/project/v1/
project.rs

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

openshift_openapi/v4_5/api/project/v1/
project.rs
