openshift_openapi/v4_5/api/build/v1/
build_request.rs

1// Generated from definition com.github.openshift.api.build.v1.BuildRequest
2
3/// BuildRequest is the resource used to pass parameters to build generator
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct BuildRequest {
6    /// binary indicates a request to build from a binary provided to the builder
7    pub binary: Option<crate::api::build::v1::BinaryBuildSource>,
8
9    /// DockerStrategyOptions contains additional docker-strategy specific options for the build
10    pub docker_strategy_options: Option<crate::api::build::v1::DockerStrategyOptions>,
11
12    /// env contains additional environment variables you want to pass into a builder container.
13    pub env: Option<Vec<k8s_openapi::api::core::v1::EnvVar>>,
14
15    /// from is the reference to the ImageStreamTag that triggered the build.
16    pub from: Option<k8s_openapi::api::core::v1::ObjectReference>,
17
18    /// lastVersion (optional) is the LastVersion of the BuildConfig that was used to generate the build. If the BuildConfig in the generator doesn't match, a build will not be generated.
19    pub last_version: Option<i64>,
20
21    /// metadata for BuildRequest.
22    pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
23
24    /// revision is the information from the source for a specific repo snapshot.
25    pub revision: Option<crate::api::build::v1::SourceRevision>,
26
27    /// SourceStrategyOptions contains additional source-strategy specific options for the build
28    pub source_strategy_options: Option<crate::api::build::v1::SourceStrategyOptions>,
29
30    /// triggeredBy describes which triggers started the most recent update to the build configuration and contains information about those triggers.
31    pub triggered_by: Vec<crate::api::build::v1::BuildTriggerCause>,
32
33    /// triggeredByImage is the Image that triggered this build.
34    pub triggered_by_image: Option<k8s_openapi::api::core::v1::ObjectReference>,
35}
36
37// Begin build.openshift.io/v1/BuildRequest
38
39// Generated from operation createBuildOpenshiftIoV1NamespacedBuildClone
40
41impl BuildRequest {
42    /// create clone of a Build
43    ///
44    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
45    ///
46    /// # Arguments
47    ///
48    /// * `name`
49    ///
50    ///     name of the BuildRequest
51    ///
52    /// * `namespace`
53    ///
54    ///     object name and auth scope, such as for teams and projects
55    ///
56    /// * `body`
57    ///
58    /// * `optional`
59    ///
60    ///     Optional parameters. Use `Default::default()` to not pass any.
61    #[cfg(feature = "api")]
62    pub fn create_namespaced_build_clone(
63        name: &str,
64        namespace: &str,
65        body: &crate::api::build::v1::BuildRequest,
66        optional: k8s_openapi::CreateOptional<'_>,
67    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
68        let __url = format!("/apis/build.openshift.io/v1/namespaces/{namespace}/builds/{name}/clone?",
69            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
70            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
71        );
72        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
73        optional.__serialize(&mut __query_pairs);
74        let __url = __query_pairs.finish();
75
76        let __request = http::Request::post(__url);
77        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
78        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
79        match __request.body(__body) {
80            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
81            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
82        }
83    }
84}
85
86// Generated from operation createBuildOpenshiftIoV1NamespacedBuildConfigInstantiate
87
88impl BuildRequest {
89    /// create instantiate of a BuildConfig
90    ///
91    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`CreateNamespacedBuildConfigInstantiateResponse`]`>` constructor, or [`CreateNamespacedBuildConfigInstantiateResponse`] directly, to parse the HTTP response.
92    ///
93    /// # Arguments
94    ///
95    /// * `name`
96    ///
97    ///     name of the BuildRequest
98    ///
99    /// * `namespace`
100    ///
101    ///     object name and auth scope, such as for teams and projects
102    ///
103    /// * `body`
104    ///
105    /// * `optional`
106    ///
107    ///     Optional parameters. Use `Default::default()` to not pass any.
108    #[cfg(feature = "api")]
109    pub fn create_namespaced_build_config_instantiate(
110        name: &str,
111        namespace: &str,
112        body: &crate::api::build::v1::BuildRequest,
113        optional: k8s_openapi::CreateOptional<'_>,
114    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<CreateNamespacedBuildConfigInstantiateResponse>), k8s_openapi::RequestError> {
115        let __url = format!("/apis/build.openshift.io/v1/namespaces/{namespace}/buildconfigs/{name}/instantiate?",
116            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
117            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
118        );
119        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
120        optional.__serialize(&mut __query_pairs);
121        let __url = __query_pairs.finish();
122
123        let __request = http::Request::post(__url);
124        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
125        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
126        match __request.body(__body) {
127            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
128            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
129        }
130    }
131}
132
133/// Use `<CreateNamespacedBuildConfigInstantiateResponse as Response>::try_from_parts` to parse the HTTP response body of [`BuildRequest::create_namespaced_build_config_instantiate`]
134#[cfg(feature = "api")]
135#[derive(Debug)]
136pub enum CreateNamespacedBuildConfigInstantiateResponse {
137    Ok(crate::api::build::v1::Build),
138    Created(crate::api::build::v1::Build),
139    Accepted(crate::api::build::v1::Build),
140    Other(Result<Option<serde_json::Value>, serde_json::Error>),
141}
142
143#[cfg(feature = "api")]
144impl k8s_openapi::Response for CreateNamespacedBuildConfigInstantiateResponse {
145    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
146        match status_code {
147            http::StatusCode::OK => {
148                let result = match serde_json::from_slice(buf) {
149                    Ok(value) => value,
150                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
151                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
152                };
153                Ok((CreateNamespacedBuildConfigInstantiateResponse::Ok(result), buf.len()))
154            },
155            http::StatusCode::CREATED => {
156                let result = match serde_json::from_slice(buf) {
157                    Ok(value) => value,
158                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
159                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
160                };
161                Ok((CreateNamespacedBuildConfigInstantiateResponse::Created(result), buf.len()))
162            },
163            http::StatusCode::ACCEPTED => {
164                let result = match serde_json::from_slice(buf) {
165                    Ok(value) => value,
166                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
167                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
168                };
169                Ok((CreateNamespacedBuildConfigInstantiateResponse::Accepted(result), buf.len()))
170            },
171            _ => {
172                let (result, read) =
173                    if buf.is_empty() {
174                        (Ok(None), 0)
175                    }
176                    else {
177                        match serde_json::from_slice(buf) {
178                            Ok(value) => (Ok(Some(value)), buf.len()),
179                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
180                            Err(err) => (Err(err), 0),
181                        }
182                    };
183                Ok((CreateNamespacedBuildConfigInstantiateResponse::Other(result), read))
184            },
185        }
186    }
187}
188
189// End build.openshift.io/v1/BuildRequest
190
191impl k8s_openapi::Resource for BuildRequest {
192    const API_VERSION: &'static str = "build.openshift.io/v1";
193    const GROUP: &'static str = "build.openshift.io";
194    const KIND: &'static str = "BuildRequest";
195    const VERSION: &'static str = "v1";
196}
197
198impl k8s_openapi::Metadata for BuildRequest {
199    type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
200
201    fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
202        &self.metadata
203    }
204
205    fn metadata_mut(&mut self) -> &mut<Self as k8s_openapi::Metadata>::Ty {
206        &mut self.metadata
207    }
208}
209
210impl<'de> serde::Deserialize<'de> for BuildRequest {
211    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
212        #[allow(non_camel_case_types)]
213        enum Field {
214            Key_api_version,
215            Key_kind,
216            Key_binary,
217            Key_docker_strategy_options,
218            Key_env,
219            Key_from,
220            Key_last_version,
221            Key_metadata,
222            Key_revision,
223            Key_source_strategy_options,
224            Key_triggered_by,
225            Key_triggered_by_image,
226            Other,
227        }
228
229        impl<'de> serde::Deserialize<'de> for Field {
230            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
231                struct Visitor;
232
233                impl<'de> serde::de::Visitor<'de> for Visitor {
234                    type Value = Field;
235
236                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
237                        f.write_str("field identifier")
238                    }
239
240                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
241                        Ok(match v {
242                            "apiVersion" => Field::Key_api_version,
243                            "kind" => Field::Key_kind,
244                            "binary" => Field::Key_binary,
245                            "dockerStrategyOptions" => Field::Key_docker_strategy_options,
246                            "env" => Field::Key_env,
247                            "from" => Field::Key_from,
248                            "lastVersion" => Field::Key_last_version,
249                            "metadata" => Field::Key_metadata,
250                            "revision" => Field::Key_revision,
251                            "sourceStrategyOptions" => Field::Key_source_strategy_options,
252                            "triggeredBy" => Field::Key_triggered_by,
253                            "triggeredByImage" => Field::Key_triggered_by_image,
254                            _ => Field::Other,
255                        })
256                    }
257                }
258
259                deserializer.deserialize_identifier(Visitor)
260            }
261        }
262
263        struct Visitor;
264
265        impl<'de> serde::de::Visitor<'de> for Visitor {
266            type Value = BuildRequest;
267
268            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
269                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
270            }
271
272            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
273                let mut value_binary: Option<crate::api::build::v1::BinaryBuildSource> = None;
274                let mut value_docker_strategy_options: Option<crate::api::build::v1::DockerStrategyOptions> = None;
275                let mut value_env: Option<Vec<k8s_openapi::api::core::v1::EnvVar>> = None;
276                let mut value_from: Option<k8s_openapi::api::core::v1::ObjectReference> = None;
277                let mut value_last_version: Option<i64> = None;
278                let mut value_metadata: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
279                let mut value_revision: Option<crate::api::build::v1::SourceRevision> = None;
280                let mut value_source_strategy_options: Option<crate::api::build::v1::SourceStrategyOptions> = None;
281                let mut value_triggered_by: Option<Vec<crate::api::build::v1::BuildTriggerCause>> = None;
282                let mut value_triggered_by_image: Option<k8s_openapi::api::core::v1::ObjectReference> = None;
283
284                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
285                    match key {
286                        Field::Key_api_version => {
287                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
288                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
289                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
290                            }
291                        },
292                        Field::Key_kind => {
293                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
294                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
295                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
296                            }
297                        },
298                        Field::Key_binary => value_binary = serde::de::MapAccess::next_value(&mut map)?,
299                        Field::Key_docker_strategy_options => value_docker_strategy_options = serde::de::MapAccess::next_value(&mut map)?,
300                        Field::Key_env => value_env = serde::de::MapAccess::next_value(&mut map)?,
301                        Field::Key_from => value_from = serde::de::MapAccess::next_value(&mut map)?,
302                        Field::Key_last_version => value_last_version = serde::de::MapAccess::next_value(&mut map)?,
303                        Field::Key_metadata => value_metadata = Some(serde::de::MapAccess::next_value(&mut map)?),
304                        Field::Key_revision => value_revision = serde::de::MapAccess::next_value(&mut map)?,
305                        Field::Key_source_strategy_options => value_source_strategy_options = serde::de::MapAccess::next_value(&mut map)?,
306                        Field::Key_triggered_by => value_triggered_by = Some(serde::de::MapAccess::next_value(&mut map)?),
307                        Field::Key_triggered_by_image => value_triggered_by_image = serde::de::MapAccess::next_value(&mut map)?,
308                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
309                    }
310                }
311
312                Ok(BuildRequest {
313                    binary: value_binary,
314                    docker_strategy_options: value_docker_strategy_options,
315                    env: value_env,
316                    from: value_from,
317                    last_version: value_last_version,
318                    metadata: value_metadata.ok_or_else(|| serde::de::Error::missing_field("metadata"))?,
319                    revision: value_revision,
320                    source_strategy_options: value_source_strategy_options,
321                    triggered_by: value_triggered_by.ok_or_else(|| serde::de::Error::missing_field("triggeredBy"))?,
322                    triggered_by_image: value_triggered_by_image,
323                })
324            }
325        }
326
327        deserializer.deserialize_struct(
328            <Self as k8s_openapi::Resource>::KIND,
329            &[
330                "apiVersion",
331                "kind",
332                "binary",
333                "dockerStrategyOptions",
334                "env",
335                "from",
336                "lastVersion",
337                "metadata",
338                "revision",
339                "sourceStrategyOptions",
340                "triggeredBy",
341                "triggeredByImage",
342            ],
343            Visitor,
344        )
345    }
346}
347
348impl serde::Serialize for BuildRequest {
349    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
350        let mut state = serializer.serialize_struct(
351            <Self as k8s_openapi::Resource>::KIND,
352            4 +
353            self.binary.as_ref().map_or(0, |_| 1) +
354            self.docker_strategy_options.as_ref().map_or(0, |_| 1) +
355            self.env.as_ref().map_or(0, |_| 1) +
356            self.from.as_ref().map_or(0, |_| 1) +
357            self.last_version.as_ref().map_or(0, |_| 1) +
358            self.revision.as_ref().map_or(0, |_| 1) +
359            self.source_strategy_options.as_ref().map_or(0, |_| 1) +
360            self.triggered_by_image.as_ref().map_or(0, |_| 1),
361        )?;
362        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
363        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
364        if let Some(value) = &self.binary {
365            serde::ser::SerializeStruct::serialize_field(&mut state, "binary", value)?;
366        }
367        if let Some(value) = &self.docker_strategy_options {
368            serde::ser::SerializeStruct::serialize_field(&mut state, "dockerStrategyOptions", value)?;
369        }
370        if let Some(value) = &self.env {
371            serde::ser::SerializeStruct::serialize_field(&mut state, "env", value)?;
372        }
373        if let Some(value) = &self.from {
374            serde::ser::SerializeStruct::serialize_field(&mut state, "from", value)?;
375        }
376        if let Some(value) = &self.last_version {
377            serde::ser::SerializeStruct::serialize_field(&mut state, "lastVersion", value)?;
378        }
379        serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
380        if let Some(value) = &self.revision {
381            serde::ser::SerializeStruct::serialize_field(&mut state, "revision", value)?;
382        }
383        if let Some(value) = &self.source_strategy_options {
384            serde::ser::SerializeStruct::serialize_field(&mut state, "sourceStrategyOptions", value)?;
385        }
386        serde::ser::SerializeStruct::serialize_field(&mut state, "triggeredBy", &self.triggered_by)?;
387        if let Some(value) = &self.triggered_by_image {
388            serde::ser::SerializeStruct::serialize_field(&mut state, "triggeredByImage", value)?;
389        }
390        serde::ser::SerializeStruct::end(state)
391    }
392}
openshift_openapi/v4_5/api/build/v1/build_request.rs

openshift_openapi/v4_5/api/build/v1/
build_request.rs
