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

1// Generated from definition com.github.openshift.api.apps.v1.DeploymentRequest
2
3/// DeploymentRequest is a request to a deployment config for a new deployment.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct DeploymentRequest {
6    /// ExcludeTriggers instructs the instantiator to avoid processing the specified triggers. This field overrides the triggers from latest and allows clients to control specific logic. This field is ignored if not specified.
7    pub exclude_triggers: Option<Vec<String>>,
8
9    /// Force will try to force a new deployment to run. If the deployment config is paused, then setting this to true will return an Invalid error.
10    pub force: bool,
11
12    /// Latest will update the deployment config with the latest state from all triggers.
13    pub latest: bool,
14
15    /// Name of the deployment config for requesting a new deployment.
16    pub name: String,
17}
18
19// Begin apps.openshift.io/v1/DeploymentRequest
20
21// Generated from operation createAppsOpenshiftIoV1NamespacedDeploymentConfigInstantiate
22
23impl DeploymentRequest {
24    /// create instantiate of a DeploymentConfig
25    ///
26    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
27    ///
28    /// # Arguments
29    ///
30    /// * `name`
31    ///
32    ///     name of the DeploymentRequest
33    ///
34    /// * `namespace`
35    ///
36    ///     object name and auth scope, such as for teams and projects
37    ///
38    /// * `body`
39    ///
40    /// * `optional`
41    ///
42    ///     Optional parameters. Use `Default::default()` to not pass any.
43    #[cfg(feature = "api")]
44    pub fn create_namespaced_deployment_config_instantiate(
45        name: &str,
46        namespace: &str,
47        body: &crate::api::apps::v1::DeploymentRequest,
48        optional: k8s_openapi::CreateOptional<'_>,
49    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
50        let __url = format!("/apis/apps.openshift.io/v1/namespaces/{namespace}/deploymentconfigs/{name}/instantiate?",
51            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
52            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
53        );
54        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
55        optional.__serialize(&mut __query_pairs);
56        let __url = __query_pairs.finish();
57
58        let __request = http::Request::post(__url);
59        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
60        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
61        match __request.body(__body) {
62            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
63            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
64        }
65    }
66}
67
68// End apps.openshift.io/v1/DeploymentRequest
69
70impl k8s_openapi::Resource for DeploymentRequest {
71    const API_VERSION: &'static str = "apps.openshift.io/v1";
72    const GROUP: &'static str = "apps.openshift.io";
73    const KIND: &'static str = "DeploymentRequest";
74    const VERSION: &'static str = "v1";
75}
76
77impl<'de> serde::Deserialize<'de> for DeploymentRequest {
78    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
79        #[allow(non_camel_case_types)]
80        enum Field {
81            Key_api_version,
82            Key_kind,
83            Key_exclude_triggers,
84            Key_force,
85            Key_latest,
86            Key_name,
87            Other,
88        }
89
90        impl<'de> serde::Deserialize<'de> for Field {
91            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
92                struct Visitor;
93
94                impl<'de> serde::de::Visitor<'de> for Visitor {
95                    type Value = Field;
96
97                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
98                        f.write_str("field identifier")
99                    }
100
101                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
102                        Ok(match v {
103                            "apiVersion" => Field::Key_api_version,
104                            "kind" => Field::Key_kind,
105                            "excludeTriggers" => Field::Key_exclude_triggers,
106                            "force" => Field::Key_force,
107                            "latest" => Field::Key_latest,
108                            "name" => Field::Key_name,
109                            _ => Field::Other,
110                        })
111                    }
112                }
113
114                deserializer.deserialize_identifier(Visitor)
115            }
116        }
117
118        struct Visitor;
119
120        impl<'de> serde::de::Visitor<'de> for Visitor {
121            type Value = DeploymentRequest;
122
123            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
124                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
125            }
126
127            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
128                let mut value_exclude_triggers: Option<Vec<String>> = None;
129                let mut value_force: Option<bool> = None;
130                let mut value_latest: Option<bool> = None;
131                let mut value_name: Option<String> = None;
132
133                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
134                    match key {
135                        Field::Key_api_version => {
136                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
137                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
138                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
139                            }
140                        },
141                        Field::Key_kind => {
142                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
143                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
144                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
145                            }
146                        },
147                        Field::Key_exclude_triggers => value_exclude_triggers = serde::de::MapAccess::next_value(&mut map)?,
148                        Field::Key_force => value_force = Some(serde::de::MapAccess::next_value(&mut map)?),
149                        Field::Key_latest => value_latest = Some(serde::de::MapAccess::next_value(&mut map)?),
150                        Field::Key_name => value_name = Some(serde::de::MapAccess::next_value(&mut map)?),
151                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
152                    }
153                }
154
155                Ok(DeploymentRequest {
156                    exclude_triggers: value_exclude_triggers,
157                    force: value_force.ok_or_else(|| serde::de::Error::missing_field("force"))?,
158                    latest: value_latest.ok_or_else(|| serde::de::Error::missing_field("latest"))?,
159                    name: value_name.ok_or_else(|| serde::de::Error::missing_field("name"))?,
160                })
161            }
162        }
163
164        deserializer.deserialize_struct(
165            <Self as k8s_openapi::Resource>::KIND,
166            &[
167                "apiVersion",
168                "kind",
169                "excludeTriggers",
170                "force",
171                "latest",
172                "name",
173            ],
174            Visitor,
175        )
176    }
177}
178
179impl serde::Serialize for DeploymentRequest {
180    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
181        let mut state = serializer.serialize_struct(
182            <Self as k8s_openapi::Resource>::KIND,
183            5 +
184            self.exclude_triggers.as_ref().map_or(0, |_| 1),
185        )?;
186        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
187        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
188        if let Some(value) = &self.exclude_triggers {
189            serde::ser::SerializeStruct::serialize_field(&mut state, "excludeTriggers", value)?;
190        }
191        serde::ser::SerializeStruct::serialize_field(&mut state, "force", &self.force)?;
192        serde::ser::SerializeStruct::serialize_field(&mut state, "latest", &self.latest)?;
193        serde::ser::SerializeStruct::serialize_field(&mut state, "name", &self.name)?;
194        serde::ser::SerializeStruct::end(state)
195    }
196}
openshift_openapi/v4_5/api/apps/v1/deployment_request.rs

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