openshift_openapi/v4_5/api/image/v1/
image_stream.rs

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

openshift_openapi/v4_5/api/image/v1/
image_stream.rs
