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

1// Generated from definition com.github.openshift.api.image.v1.ImageSignature
2
3/// ImageSignature holds a signature of an image. It allows to verify image identity and possibly other claims as long as the signature is trusted. Based on this information it is possible to restrict runnable images to those matching cluster-wide policy. Mandatory fields should be parsed by clients doing image verification. The others are parsed from signature's content by the server. They serve just an informative purpose.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct ImageSignature {
6    /// Conditions represent the latest available observations of a signature's current state.
7    pub conditions: Option<Vec<crate::api::image::v1::SignatureCondition>>,
8
9    /// Required: An opaque binary string which is an image's signature.
10    pub content: k8s_openapi::ByteString,
11
12    /// If specified, it is the time of signature's creation.
13    pub created: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::Time>,
14
15    /// A human readable string representing image's identity. It could be a product name and version, or an image pull spec (e.g. "registry.access.redhat.com/rhel7/rhel:7.2").
16    pub image_identity: Option<String>,
17
18    /// If specified, it holds information about an issuer of signing certificate or key (a person or entity who signed the signing certificate or key).
19    pub issued_by: Option<crate::api::image::v1::SignatureIssuer>,
20
21    /// If specified, it holds information about a subject of signing certificate or key (a person or entity who signed the image).
22    pub issued_to: Option<crate::api::image::v1::SignatureSubject>,
23
24    /// Standard object's metadata.
25    pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
26
27    /// Contains claims from the signature.
28    pub signed_claims: Option<std::collections::BTreeMap<String, String>>,
29
30    /// Required: Describes a type of stored blob.
31    pub type_: String,
32}
33
34// Begin image.openshift.io/v1/ImageSignature
35
36// Generated from operation createImageOpenshiftIoV1ImageSignature
37
38impl ImageSignature {
39    /// create an ImageSignature
40    ///
41    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
42    ///
43    /// # Arguments
44    ///
45    /// * `body`
46    ///
47    /// * `optional`
48    ///
49    ///     Optional parameters. Use `Default::default()` to not pass any.
50    #[cfg(feature = "api")]
51    pub fn create_image_signature(
52        body: &crate::api::image::v1::ImageSignature,
53        optional: k8s_openapi::CreateOptional<'_>,
54    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
55        let __url = "/apis/image.openshift.io/v1/imagesignatures?".to_owned();
56        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
57        optional.__serialize(&mut __query_pairs);
58        let __url = __query_pairs.finish();
59
60        let __request = http::Request::post(__url);
61        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
62        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
63        match __request.body(__body) {
64            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
65            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
66        }
67    }
68}
69
70// Generated from operation deleteImageOpenshiftIoV1ImageSignature
71
72impl ImageSignature {
73    /// delete an ImageSignature
74    ///
75    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::DeleteResponse`]`<Self>>` constructor, or [`k8s_openapi::DeleteResponse`]`<Self>` directly, to parse the HTTP response.
76    ///
77    /// # Arguments
78    ///
79    /// * `name`
80    ///
81    ///     name of the ImageSignature
82    ///
83    /// * `optional`
84    ///
85    ///     Optional parameters. Use `Default::default()` to not pass any.
86    #[cfg(feature = "api")]
87    pub fn delete_image_signature(
88        name: &str,
89        optional: k8s_openapi::DeleteOptional<'_>,
90    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::DeleteResponse<Self>>), k8s_openapi::RequestError> {
91        let __url = format!("/apis/image.openshift.io/v1/imagesignatures/{name}",
92            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
93        );
94
95        let __request = http::Request::delete(__url);
96        let __body = serde_json::to_vec(&optional).map_err(k8s_openapi::RequestError::Json)?;
97        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
98        match __request.body(__body) {
99            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
100            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
101        }
102    }
103}
104
105// End image.openshift.io/v1/ImageSignature
106
107impl k8s_openapi::Resource for ImageSignature {
108    const API_VERSION: &'static str = "image.openshift.io/v1";
109    const GROUP: &'static str = "image.openshift.io";
110    const KIND: &'static str = "ImageSignature";
111    const VERSION: &'static str = "v1";
112}
113
114impl k8s_openapi::Metadata for ImageSignature {
115    type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
116
117    fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
118        &self.metadata
119    }
120
121    fn metadata_mut(&mut self) -> &mut<Self as k8s_openapi::Metadata>::Ty {
122        &mut self.metadata
123    }
124}
125
126impl<'de> serde::Deserialize<'de> for ImageSignature {
127    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
128        #[allow(non_camel_case_types)]
129        enum Field {
130            Key_api_version,
131            Key_kind,
132            Key_conditions,
133            Key_content,
134            Key_created,
135            Key_image_identity,
136            Key_issued_by,
137            Key_issued_to,
138            Key_metadata,
139            Key_signed_claims,
140            Key_type_,
141            Other,
142        }
143
144        impl<'de> serde::Deserialize<'de> for Field {
145            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
146                struct Visitor;
147
148                impl<'de> serde::de::Visitor<'de> for Visitor {
149                    type Value = Field;
150
151                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
152                        f.write_str("field identifier")
153                    }
154
155                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
156                        Ok(match v {
157                            "apiVersion" => Field::Key_api_version,
158                            "kind" => Field::Key_kind,
159                            "conditions" => Field::Key_conditions,
160                            "content" => Field::Key_content,
161                            "created" => Field::Key_created,
162                            "imageIdentity" => Field::Key_image_identity,
163                            "issuedBy" => Field::Key_issued_by,
164                            "issuedTo" => Field::Key_issued_to,
165                            "metadata" => Field::Key_metadata,
166                            "signedClaims" => Field::Key_signed_claims,
167                            "type" => Field::Key_type_,
168                            _ => Field::Other,
169                        })
170                    }
171                }
172
173                deserializer.deserialize_identifier(Visitor)
174            }
175        }
176
177        struct Visitor;
178
179        impl<'de> serde::de::Visitor<'de> for Visitor {
180            type Value = ImageSignature;
181
182            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
183                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
184            }
185
186            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
187                let mut value_conditions: Option<Vec<crate::api::image::v1::SignatureCondition>> = None;
188                let mut value_content: Option<k8s_openapi::ByteString> = None;
189                let mut value_created: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::Time> = None;
190                let mut value_image_identity: Option<String> = None;
191                let mut value_issued_by: Option<crate::api::image::v1::SignatureIssuer> = None;
192                let mut value_issued_to: Option<crate::api::image::v1::SignatureSubject> = None;
193                let mut value_metadata: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
194                let mut value_signed_claims: Option<std::collections::BTreeMap<String, String>> = None;
195                let mut value_type_: Option<String> = None;
196
197                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
198                    match key {
199                        Field::Key_api_version => {
200                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
201                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
202                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
203                            }
204                        },
205                        Field::Key_kind => {
206                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
207                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
208                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
209                            }
210                        },
211                        Field::Key_conditions => value_conditions = serde::de::MapAccess::next_value(&mut map)?,
212                        Field::Key_content => value_content = Some(serde::de::MapAccess::next_value(&mut map)?),
213                        Field::Key_created => value_created = serde::de::MapAccess::next_value(&mut map)?,
214                        Field::Key_image_identity => value_image_identity = serde::de::MapAccess::next_value(&mut map)?,
215                        Field::Key_issued_by => value_issued_by = serde::de::MapAccess::next_value(&mut map)?,
216                        Field::Key_issued_to => value_issued_to = serde::de::MapAccess::next_value(&mut map)?,
217                        Field::Key_metadata => value_metadata = Some(serde::de::MapAccess::next_value(&mut map)?),
218                        Field::Key_signed_claims => value_signed_claims = serde::de::MapAccess::next_value(&mut map)?,
219                        Field::Key_type_ => value_type_ = Some(serde::de::MapAccess::next_value(&mut map)?),
220                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
221                    }
222                }
223
224                Ok(ImageSignature {
225                    conditions: value_conditions,
226                    content: value_content.ok_or_else(|| serde::de::Error::missing_field("content"))?,
227                    created: value_created,
228                    image_identity: value_image_identity,
229                    issued_by: value_issued_by,
230                    issued_to: value_issued_to,
231                    metadata: value_metadata.ok_or_else(|| serde::de::Error::missing_field("metadata"))?,
232                    signed_claims: value_signed_claims,
233                    type_: value_type_.ok_or_else(|| serde::de::Error::missing_field("type"))?,
234                })
235            }
236        }
237
238        deserializer.deserialize_struct(
239            <Self as k8s_openapi::Resource>::KIND,
240            &[
241                "apiVersion",
242                "kind",
243                "conditions",
244                "content",
245                "created",
246                "imageIdentity",
247                "issuedBy",
248                "issuedTo",
249                "metadata",
250                "signedClaims",
251                "type",
252            ],
253            Visitor,
254        )
255    }
256}
257
258impl serde::Serialize for ImageSignature {
259    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
260        let mut state = serializer.serialize_struct(
261            <Self as k8s_openapi::Resource>::KIND,
262            5 +
263            self.conditions.as_ref().map_or(0, |_| 1) +
264            self.created.as_ref().map_or(0, |_| 1) +
265            self.image_identity.as_ref().map_or(0, |_| 1) +
266            self.issued_by.as_ref().map_or(0, |_| 1) +
267            self.issued_to.as_ref().map_or(0, |_| 1) +
268            self.signed_claims.as_ref().map_or(0, |_| 1),
269        )?;
270        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
271        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
272        if let Some(value) = &self.conditions {
273            serde::ser::SerializeStruct::serialize_field(&mut state, "conditions", value)?;
274        }
275        serde::ser::SerializeStruct::serialize_field(&mut state, "content", &self.content)?;
276        if let Some(value) = &self.created {
277            serde::ser::SerializeStruct::serialize_field(&mut state, "created", value)?;
278        }
279        if let Some(value) = &self.image_identity {
280            serde::ser::SerializeStruct::serialize_field(&mut state, "imageIdentity", value)?;
281        }
282        if let Some(value) = &self.issued_by {
283            serde::ser::SerializeStruct::serialize_field(&mut state, "issuedBy", value)?;
284        }
285        if let Some(value) = &self.issued_to {
286            serde::ser::SerializeStruct::serialize_field(&mut state, "issuedTo", value)?;
287        }
288        serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
289        if let Some(value) = &self.signed_claims {
290            serde::ser::SerializeStruct::serialize_field(&mut state, "signedClaims", value)?;
291        }
292        serde::ser::SerializeStruct::serialize_field(&mut state, "type", &self.type_)?;
293        serde::ser::SerializeStruct::end(state)
294    }
295}
openshift_openapi/v4_5/api/image/v1/image_signature.rs

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