openshift_openapi/v4_5/api/apps/v1/
deployment_config.rs

1// Generated from definition com.github.openshift.api.apps.v1.DeploymentConfig
2
3/// Deployment Configs define the template for a pod and manages deploying new images or configuration changes. A single deployment configuration is usually analogous to a single micro-service. Can support many different deployment patterns, including full restart, customizable rolling updates, and  fully custom behaviors, as well as pre- and post- deployment hooks. Each individual deployment is represented as a replication controller.
4///
5/// A deployment is "triggered" when its configuration is changed or a tag in an Image Stream is changed. Triggers can be disabled to allow manual control over a deployment. The "strategy" determines how the deployment is carried out and may be changed at any time. The `latestVersion` field is updated when a new deployment is triggered by any means.
6#[derive(Clone, Debug, Default, PartialEq)]
7pub struct DeploymentConfig {
8    /// Standard object's metadata.
9    pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
10
11    /// Spec represents a desired deployment state and how to deploy to it.
12    pub spec: crate::api::apps::v1::DeploymentConfigSpec,
13
14    /// Status represents the current deployment state.
15    pub status: Option<crate::api::apps::v1::DeploymentConfigStatus>,
16}
17
18// Begin apps.openshift.io/v1/DeploymentConfig
19
20// Generated from operation createAppsOpenshiftIoV1NamespacedDeploymentConfig
21
22impl DeploymentConfig {
23    /// create a DeploymentConfig
24    ///
25    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
26    ///
27    /// # Arguments
28    ///
29    /// * `namespace`
30    ///
31    ///     object name and auth scope, such as for teams and projects
32    ///
33    /// * `body`
34    ///
35    /// * `optional`
36    ///
37    ///     Optional parameters. Use `Default::default()` to not pass any.
38    #[cfg(feature = "api")]
39    pub fn create_namespaced_deployment_config(
40        namespace: &str,
41        body: &crate::api::apps::v1::DeploymentConfig,
42        optional: k8s_openapi::CreateOptional<'_>,
43    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
44        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs?",
45            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
46        );
47        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
48        optional.__serialize(&mut __query_pairs);
49        let __url = __query_pairs.finish();
50
51        let __request = http::Request::post(__url);
52        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
53        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
54        match __request.body(__body) {
55            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
56            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
57        }
58    }
59}
60
61// Generated from operation deleteAppsOpenshiftIoV1CollectionNamespacedDeploymentConfig
62
63impl DeploymentConfig {
64    /// delete collection of DeploymentConfig
65    ///
66    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::DeleteResponse`]`<`[`k8s_openapi::List`]`<Self>>>` constructor, or [`k8s_openapi::DeleteResponse`]`<`[`k8s_openapi::List`]`<Self>>` directly, to parse the HTTP response.
67    ///
68    /// # Arguments
69    ///
70    /// * `namespace`
71    ///
72    ///     object name and auth scope, such as for teams and projects
73    ///
74    /// * `delete_optional`
75    ///
76    ///     Delete options. Use `Default::default()` to not pass any.
77    ///
78    /// * `list_optional`
79    ///
80    ///     List options. Use `Default::default()` to not pass any.
81    #[cfg(feature = "api")]
82    pub fn delete_collection_namespaced_deployment_config(
83        namespace: &str,
84        delete_optional: k8s_openapi::DeleteOptional<'_>,
85        list_optional: k8s_openapi::ListOptional<'_>,
86    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::DeleteResponse<k8s_openapi::List<Self>>>), k8s_openapi::RequestError> {
87        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs?",
88            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
89        );
90        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
91        list_optional.__serialize(&mut __query_pairs);
92        let __url = __query_pairs.finish();
93
94        let __request = http::Request::delete(__url);
95        let __body = serde_json::to_vec(&delete_optional).map_err(k8s_openapi::RequestError::Json)?;
96        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
97        match __request.body(__body) {
98            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
99            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
100        }
101    }
102}
103
104// Generated from operation deleteAppsOpenshiftIoV1NamespacedDeploymentConfig
105
106impl DeploymentConfig {
107    /// delete a DeploymentConfig
108    ///
109    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::DeleteResponse`]`<Self>>` constructor, or [`k8s_openapi::DeleteResponse`]`<Self>` directly, to parse the HTTP response.
110    ///
111    /// # Arguments
112    ///
113    /// * `name`
114    ///
115    ///     name of the DeploymentConfig
116    ///
117    /// * `namespace`
118    ///
119    ///     object name and auth scope, such as for teams and projects
120    ///
121    /// * `optional`
122    ///
123    ///     Optional parameters. Use `Default::default()` to not pass any.
124    #[cfg(feature = "api")]
125    pub fn delete_namespaced_deployment_config(
126        name: &str,
127        namespace: &str,
128        optional: k8s_openapi::DeleteOptional<'_>,
129    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::DeleteResponse<Self>>), k8s_openapi::RequestError> {
130        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs/{name}",
131            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
132            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
133        );
134
135        let __request = http::Request::delete(__url);
136        let __body = serde_json::to_vec(&optional).map_err(k8s_openapi::RequestError::Json)?;
137        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
138        match __request.body(__body) {
139            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
140            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
141        }
142    }
143}
144
145// Generated from operation listAppsOpenshiftIoV1DeploymentConfigForAllNamespaces
146
147impl DeploymentConfig {
148    /// list or watch objects of kind DeploymentConfig
149    ///
150    /// This operation only supports listing all items of this type.
151    ///
152    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ListResponse`]`<Self>>` constructor, or [`k8s_openapi::ListResponse`]`<Self>` directly, to parse the HTTP response.
153    ///
154    /// # Arguments
155    ///
156    /// * `optional`
157    ///
158    ///     Optional parameters. Use `Default::default()` to not pass any.
159    #[cfg(feature = "api")]
160    pub fn list_deployment_config_for_all_namespaces(
161        optional: k8s_openapi::ListOptional<'_>,
162    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ListResponse<Self>>), k8s_openapi::RequestError> {
163        let __url = "/apis/apps.openshift.io/v1/deploymentconfigs?".to_owned();
164        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
165        optional.__serialize(&mut __query_pairs);
166        let __url = __query_pairs.finish();
167
168        let __request = http::Request::get(__url);
169        let __body = vec![];
170        match __request.body(__body) {
171            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
172            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
173        }
174    }
175}
176
177// Generated from operation listAppsOpenshiftIoV1NamespacedDeploymentConfig
178
179impl DeploymentConfig {
180    /// list or watch objects of kind DeploymentConfig
181    ///
182    /// This operation only supports listing all items of this type.
183    ///
184    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ListResponse`]`<Self>>` constructor, or [`k8s_openapi::ListResponse`]`<Self>` directly, to parse the HTTP response.
185    ///
186    /// # Arguments
187    ///
188    /// * `namespace`
189    ///
190    ///     object name and auth scope, such as for teams and projects
191    ///
192    /// * `optional`
193    ///
194    ///     Optional parameters. Use `Default::default()` to not pass any.
195    #[cfg(feature = "api")]
196    pub fn list_namespaced_deployment_config(
197        namespace: &str,
198        optional: k8s_openapi::ListOptional<'_>,
199    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ListResponse<Self>>), k8s_openapi::RequestError> {
200        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs?",
201            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
202        );
203        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
204        optional.__serialize(&mut __query_pairs);
205        let __url = __query_pairs.finish();
206
207        let __request = http::Request::get(__url);
208        let __body = vec![];
209        match __request.body(__body) {
210            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
211            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
212        }
213    }
214}
215
216// Generated from operation patchAppsOpenshiftIoV1NamespacedDeploymentConfig
217
218impl DeploymentConfig {
219    /// partially update the specified DeploymentConfig
220    ///
221    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::PatchResponse`]`<Self>>` constructor, or [`k8s_openapi::PatchResponse`]`<Self>` directly, to parse the HTTP response.
222    ///
223    /// # Arguments
224    ///
225    /// * `name`
226    ///
227    ///     name of the DeploymentConfig
228    ///
229    /// * `namespace`
230    ///
231    ///     object name and auth scope, such as for teams and projects
232    ///
233    /// * `body`
234    ///
235    /// * `optional`
236    ///
237    ///     Optional parameters. Use `Default::default()` to not pass any.
238    #[cfg(feature = "api")]
239    pub fn patch_namespaced_deployment_config(
240        name: &str,
241        namespace: &str,
242        body: &k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch,
243        optional: k8s_openapi::PatchOptional<'_>,
244    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::PatchResponse<Self>>), k8s_openapi::RequestError> {
245        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs/{name}?",
246            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
247            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
248        );
249        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
250        optional.__serialize(&mut __query_pairs);
251        let __url = __query_pairs.finish();
252
253        let __request = http::Request::patch(__url);
254        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
255        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static(match body {
256            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Json(_) => "application/json-patch+json",
257            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Merge(_) => "application/merge-patch+json",
258            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::StrategicMerge(_) => "application/strategic-merge-patch+json",
259        }));
260        match __request.body(__body) {
261            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
262            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
263        }
264    }
265}
266
267// Generated from operation patchAppsOpenshiftIoV1NamespacedDeploymentConfigStatus
268
269impl DeploymentConfig {
270    /// partially update status of the specified DeploymentConfig
271    ///
272    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::PatchResponse`]`<Self>>` constructor, or [`k8s_openapi::PatchResponse`]`<Self>` directly, to parse the HTTP response.
273    ///
274    /// # Arguments
275    ///
276    /// * `name`
277    ///
278    ///     name of the DeploymentConfig
279    ///
280    /// * `namespace`
281    ///
282    ///     object name and auth scope, such as for teams and projects
283    ///
284    /// * `body`
285    ///
286    /// * `optional`
287    ///
288    ///     Optional parameters. Use `Default::default()` to not pass any.
289    #[cfg(feature = "api")]
290    pub fn patch_namespaced_deployment_config_status(
291        name: &str,
292        namespace: &str,
293        body: &k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch,
294        optional: k8s_openapi::PatchOptional<'_>,
295    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::PatchResponse<Self>>), k8s_openapi::RequestError> {
296        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs/{name}/status?",
297            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
298            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
299        );
300        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
301        optional.__serialize(&mut __query_pairs);
302        let __url = __query_pairs.finish();
303
304        let __request = http::Request::patch(__url);
305        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
306        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static(match body {
307            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Json(_) => "application/json-patch+json",
308            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Merge(_) => "application/merge-patch+json",
309            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::StrategicMerge(_) => "application/strategic-merge-patch+json",
310        }));
311        match __request.body(__body) {
312            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
313            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
314        }
315    }
316}
317
318// Generated from operation readAppsOpenshiftIoV1NamespacedDeploymentConfig
319
320impl DeploymentConfig {
321    /// read the specified DeploymentConfig
322    ///
323    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`ReadNamespacedDeploymentConfigResponse`]`>` constructor, or [`ReadNamespacedDeploymentConfigResponse`] directly, to parse the HTTP response.
324    ///
325    /// # Arguments
326    ///
327    /// * `name`
328    ///
329    ///     name of the DeploymentConfig
330    ///
331    /// * `namespace`
332    ///
333    ///     object name and auth scope, such as for teams and projects
334    ///
335    /// * `optional`
336    ///
337    ///     Optional parameters. Use `Default::default()` to not pass any.
338    #[cfg(feature = "api")]
339    pub fn read_namespaced_deployment_config(
340        name: &str,
341        namespace: &str,
342        optional: ReadNamespacedDeploymentConfigOptional<'_>,
343    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<ReadNamespacedDeploymentConfigResponse>), k8s_openapi::RequestError> {
344        let ReadNamespacedDeploymentConfigOptional {
345            exact,
346            export,
347            pretty,
348        } = optional;
349        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs/{name}?",
350            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
351            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
352        );
353        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
354        if let Some(exact) = exact {
355            __query_pairs.append_pair("exact", &exact.to_string());
356        }
357        if let Some(export) = export {
358            __query_pairs.append_pair("export", &export.to_string());
359        }
360        if let Some(pretty) = pretty {
361            __query_pairs.append_pair("pretty", pretty);
362        }
363        let __url = __query_pairs.finish();
364
365        let __request = http::Request::get(__url);
366        let __body = vec![];
367        match __request.body(__body) {
368            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
369            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
370        }
371    }
372}
373
374/// Optional parameters of [`DeploymentConfig::read_namespaced_deployment_config`]
375#[cfg(feature = "api")]
376#[derive(Clone, Copy, Debug, Default)]
377pub struct ReadNamespacedDeploymentConfigOptional<'a> {
378    /// Should the export be exact.  Exact export maintains cluster-specific fields like 'Namespace'.
379    pub exact: Option<bool>,
380    /// Should this value be exported.  Export strips fields that a user can not specify.
381    pub export: Option<bool>,
382    /// If 'true', then the output is pretty printed.
383    pub pretty: Option<&'a str>,
384}
385
386/// Use `<ReadNamespacedDeploymentConfigResponse as Response>::try_from_parts` to parse the HTTP response body of [`DeploymentConfig::read_namespaced_deployment_config`]
387#[cfg(feature = "api")]
388#[derive(Debug)]
389pub enum ReadNamespacedDeploymentConfigResponse {
390    Ok(crate::api::apps::v1::DeploymentConfig),
391    Other(Result<Option<serde_json::Value>, serde_json::Error>),
392}
393
394#[cfg(feature = "api")]
395impl k8s_openapi::Response for ReadNamespacedDeploymentConfigResponse {
396    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
397        match status_code {
398            http::StatusCode::OK => {
399                let result = match serde_json::from_slice(buf) {
400                    Ok(value) => value,
401                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
402                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
403                };
404                Ok((ReadNamespacedDeploymentConfigResponse::Ok(result), buf.len()))
405            },
406            _ => {
407                let (result, read) =
408                    if buf.is_empty() {
409                        (Ok(None), 0)
410                    }
411                    else {
412                        match serde_json::from_slice(buf) {
413                            Ok(value) => (Ok(Some(value)), buf.len()),
414                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
415                            Err(err) => (Err(err), 0),
416                        }
417                    };
418                Ok((ReadNamespacedDeploymentConfigResponse::Other(result), read))
419            },
420        }
421    }
422}
423
424// Generated from operation readAppsOpenshiftIoV1NamespacedDeploymentConfigStatus
425
426impl DeploymentConfig {
427    /// read status of the specified DeploymentConfig
428    ///
429    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`ReadNamespacedDeploymentConfigStatusResponse`]`>` constructor, or [`ReadNamespacedDeploymentConfigStatusResponse`] directly, to parse the HTTP response.
430    ///
431    /// # Arguments
432    ///
433    /// * `name`
434    ///
435    ///     name of the DeploymentConfig
436    ///
437    /// * `namespace`
438    ///
439    ///     object name and auth scope, such as for teams and projects
440    ///
441    /// * `optional`
442    ///
443    ///     Optional parameters. Use `Default::default()` to not pass any.
444    #[cfg(feature = "api")]
445    pub fn read_namespaced_deployment_config_status(
446        name: &str,
447        namespace: &str,
448        optional: ReadNamespacedDeploymentConfigStatusOptional<'_>,
449    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<ReadNamespacedDeploymentConfigStatusResponse>), k8s_openapi::RequestError> {
450        let ReadNamespacedDeploymentConfigStatusOptional {
451            pretty,
452        } = optional;
453        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs/{name}/status?",
454            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
455            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
456        );
457        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
458        if let Some(pretty) = pretty {
459            __query_pairs.append_pair("pretty", pretty);
460        }
461        let __url = __query_pairs.finish();
462
463        let __request = http::Request::get(__url);
464        let __body = vec![];
465        match __request.body(__body) {
466            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
467            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
468        }
469    }
470}
471
472/// Optional parameters of [`DeploymentConfig::read_namespaced_deployment_config_status`]
473#[cfg(feature = "api")]
474#[derive(Clone, Copy, Debug, Default)]
475pub struct ReadNamespacedDeploymentConfigStatusOptional<'a> {
476    /// If 'true', then the output is pretty printed.
477    pub pretty: Option<&'a str>,
478}
479
480/// Use `<ReadNamespacedDeploymentConfigStatusResponse as Response>::try_from_parts` to parse the HTTP response body of [`DeploymentConfig::read_namespaced_deployment_config_status`]
481#[cfg(feature = "api")]
482#[derive(Debug)]
483pub enum ReadNamespacedDeploymentConfigStatusResponse {
484    Ok(crate::api::apps::v1::DeploymentConfig),
485    Other(Result<Option<serde_json::Value>, serde_json::Error>),
486}
487
488#[cfg(feature = "api")]
489impl k8s_openapi::Response for ReadNamespacedDeploymentConfigStatusResponse {
490    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
491        match status_code {
492            http::StatusCode::OK => {
493                let result = match serde_json::from_slice(buf) {
494                    Ok(value) => value,
495                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
496                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
497                };
498                Ok((ReadNamespacedDeploymentConfigStatusResponse::Ok(result), buf.len()))
499            },
500            _ => {
501                let (result, read) =
502                    if buf.is_empty() {
503                        (Ok(None), 0)
504                    }
505                    else {
506                        match serde_json::from_slice(buf) {
507                            Ok(value) => (Ok(Some(value)), buf.len()),
508                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
509                            Err(err) => (Err(err), 0),
510                        }
511                    };
512                Ok((ReadNamespacedDeploymentConfigStatusResponse::Other(result), read))
513            },
514        }
515    }
516}
517
518// Generated from operation replaceAppsOpenshiftIoV1NamespacedDeploymentConfig
519
520impl DeploymentConfig {
521    /// replace the specified DeploymentConfig
522    ///
523    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ReplaceResponse`]`<Self>>` constructor, or [`k8s_openapi::ReplaceResponse`]`<Self>` directly, to parse the HTTP response.
524    ///
525    /// # Arguments
526    ///
527    /// * `name`
528    ///
529    ///     name of the DeploymentConfig
530    ///
531    /// * `namespace`
532    ///
533    ///     object name and auth scope, such as for teams and projects
534    ///
535    /// * `body`
536    ///
537    /// * `optional`
538    ///
539    ///     Optional parameters. Use `Default::default()` to not pass any.
540    #[cfg(feature = "api")]
541    pub fn replace_namespaced_deployment_config(
542        name: &str,
543        namespace: &str,
544        body: &crate::api::apps::v1::DeploymentConfig,
545        optional: k8s_openapi::ReplaceOptional<'_>,
546    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ReplaceResponse<Self>>), k8s_openapi::RequestError> {
547        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs/{name}?",
548            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
549            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
550        );
551        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
552        optional.__serialize(&mut __query_pairs);
553        let __url = __query_pairs.finish();
554
555        let __request = http::Request::put(__url);
556        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
557        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
558        match __request.body(__body) {
559            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
560            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
561        }
562    }
563}
564
565// Generated from operation replaceAppsOpenshiftIoV1NamespacedDeploymentConfigStatus
566
567impl DeploymentConfig {
568    /// replace status of the specified DeploymentConfig
569    ///
570    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ReplaceResponse`]`<Self>>` constructor, or [`k8s_openapi::ReplaceResponse`]`<Self>` directly, to parse the HTTP response.
571    ///
572    /// # Arguments
573    ///
574    /// * `name`
575    ///
576    ///     name of the DeploymentConfig
577    ///
578    /// * `namespace`
579    ///
580    ///     object name and auth scope, such as for teams and projects
581    ///
582    /// * `body`
583    ///
584    /// * `optional`
585    ///
586    ///     Optional parameters. Use `Default::default()` to not pass any.
587    #[cfg(feature = "api")]
588    pub fn replace_namespaced_deployment_config_status(
589        name: &str,
590        namespace: &str,
591        body: &crate::api::apps::v1::DeploymentConfig,
592        optional: k8s_openapi::ReplaceOptional<'_>,
593    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ReplaceResponse<Self>>), k8s_openapi::RequestError> {
594        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs/{name}/status?",
595            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
596            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
597        );
598        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
599        optional.__serialize(&mut __query_pairs);
600        let __url = __query_pairs.finish();
601
602        let __request = http::Request::put(__url);
603        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
604        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
605        match __request.body(__body) {
606            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
607            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
608        }
609    }
610}
611
612// Generated from operation watchAppsOpenshiftIoV1DeploymentConfigForAllNamespaces
613
614impl DeploymentConfig {
615    /// list or watch objects of kind DeploymentConfig
616    ///
617    /// This operation only supports watching one item, or a list of items, of this type for changes.
618    ///
619    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::WatchResponse`]`<Self>>` constructor, or [`k8s_openapi::WatchResponse`]`<Self>` directly, to parse the HTTP response.
620    ///
621    /// # Arguments
622    ///
623    /// * `optional`
624    ///
625    ///     Optional parameters. Use `Default::default()` to not pass any.
626    #[cfg(feature = "api")]
627    pub fn watch_deployment_config_for_all_namespaces(
628        optional: k8s_openapi::WatchOptional<'_>,
629    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::WatchResponse<Self>>), k8s_openapi::RequestError> {
630        let __url = "/apis/apps.openshift.io/v1/deploymentconfigs?".to_owned();
631        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
632        optional.__serialize(&mut __query_pairs);
633        let __url = __query_pairs.finish();
634
635        let __request = http::Request::get(__url);
636        let __body = vec![];
637        match __request.body(__body) {
638            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
639            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
640        }
641    }
642}
643
644// Generated from operation watchAppsOpenshiftIoV1NamespacedDeploymentConfig
645
646impl DeploymentConfig {
647    /// list or watch objects of kind DeploymentConfig
648    ///
649    /// This operation only supports watching one item, or a list of items, of this type for changes.
650    ///
651    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::WatchResponse`]`<Self>>` constructor, or [`k8s_openapi::WatchResponse`]`<Self>` directly, to parse the HTTP response.
652    ///
653    /// # Arguments
654    ///
655    /// * `namespace`
656    ///
657    ///     object name and auth scope, such as for teams and projects
658    ///
659    /// * `optional`
660    ///
661    ///     Optional parameters. Use `Default::default()` to not pass any.
662    #[cfg(feature = "api")]
663    pub fn watch_namespaced_deployment_config(
664        namespace: &str,
665        optional: k8s_openapi::WatchOptional<'_>,
666    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::WatchResponse<Self>>), k8s_openapi::RequestError> {
667        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs?",
668            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
669        );
670        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
671        optional.__serialize(&mut __query_pairs);
672        let __url = __query_pairs.finish();
673
674        let __request = http::Request::get(__url);
675        let __body = vec![];
676        match __request.body(__body) {
677            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
678            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
679        }
680    }
681}
682
683// End apps.openshift.io/v1/DeploymentConfig
684
685impl k8s_openapi::Resource for DeploymentConfig {
686    const API_VERSION: &'static str = "apps.openshift.io/v1";
687    const GROUP: &'static str = "apps.openshift.io";
688    const KIND: &'static str = "DeploymentConfig";
689    const VERSION: &'static str = "v1";
690}
691
692impl k8s_openapi::ListableResource for DeploymentConfig {
693    const LIST_KIND: &'static str = concat!("DeploymentConfig", "List");
694}
695
696impl k8s_openapi::Metadata for DeploymentConfig {
697    type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
698
699    fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
700        &self.metadata
701    }
702
703    fn metadata_mut(&mut self) -> &mut<Self as k8s_openapi::Metadata>::Ty {
704        &mut self.metadata
705    }
706}
707
708impl<'de> serde::Deserialize<'de> for DeploymentConfig {
709    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
710        #[allow(non_camel_case_types)]
711        enum Field {
712            Key_api_version,
713            Key_kind,
714            Key_metadata,
715            Key_spec,
716            Key_status,
717            Other,
718        }
719
720        impl<'de> serde::Deserialize<'de> for Field {
721            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
722                struct Visitor;
723
724                impl<'de> serde::de::Visitor<'de> for Visitor {
725                    type Value = Field;
726
727                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
728                        f.write_str("field identifier")
729                    }
730
731                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
732                        Ok(match v {
733                            "apiVersion" => Field::Key_api_version,
734                            "kind" => Field::Key_kind,
735                            "metadata" => Field::Key_metadata,
736                            "spec" => Field::Key_spec,
737                            "status" => Field::Key_status,
738                            _ => Field::Other,
739                        })
740                    }
741                }
742
743                deserializer.deserialize_identifier(Visitor)
744            }
745        }
746
747        struct Visitor;
748
749        impl<'de> serde::de::Visitor<'de> for Visitor {
750            type Value = DeploymentConfig;
751
752            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
753                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
754            }
755
756            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
757                let mut value_metadata: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
758                let mut value_spec: Option<crate::api::apps::v1::DeploymentConfigSpec> = None;
759                let mut value_status: Option<crate::api::apps::v1::DeploymentConfigStatus> = None;
760
761                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
762                    match key {
763                        Field::Key_api_version => {
764                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
765                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
766                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
767                            }
768                        },
769                        Field::Key_kind => {
770                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
771                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
772                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
773                            }
774                        },
775                        Field::Key_metadata => value_metadata = Some(serde::de::MapAccess::next_value(&mut map)?),
776                        Field::Key_spec => value_spec = Some(serde::de::MapAccess::next_value(&mut map)?),
777                        Field::Key_status => value_status = serde::de::MapAccess::next_value(&mut map)?,
778                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
779                    }
780                }
781
782                Ok(DeploymentConfig {
783                    metadata: value_metadata.ok_or_else(|| serde::de::Error::missing_field("metadata"))?,
784                    spec: value_spec.ok_or_else(|| serde::de::Error::missing_field("spec"))?,
785                    status: value_status,
786                })
787            }
788        }
789
790        deserializer.deserialize_struct(
791            <Self as k8s_openapi::Resource>::KIND,
792            &[
793                "apiVersion",
794                "kind",
795                "metadata",
796                "spec",
797                "status",
798            ],
799            Visitor,
800        )
801    }
802}
803
804impl serde::Serialize for DeploymentConfig {
805    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
806        let mut state = serializer.serialize_struct(
807            <Self as k8s_openapi::Resource>::KIND,
808            4 +
809            self.status.as_ref().map_or(0, |_| 1),
810        )?;
811        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
812        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
813        serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
814        serde::ser::SerializeStruct::serialize_field(&mut state, "spec", &self.spec)?;
815        if let Some(value) = &self.status {
816            serde::ser::SerializeStruct::serialize_field(&mut state, "status", value)?;
817        }
818        serde::ser::SerializeStruct::end(state)
819    }
820}
openshift_openapi/v4_5/api/apps/v1/deployment_config.rs

openshift_openapi/v4_5/api/apps/v1/
deployment_config.rs
