openshift_openapi/v4_5/api/route/v1/
route.rs

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

openshift_openapi/v4_5/api/route/v1/
route.rs
