#
k8s_openapi/v1_35/apiextensions_apiserver/pkg/apis/apiextensions/v1/
webhook_conversion.rs

    1// Generated from definition io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion
    2
    3/// WebhookConversion describes how to call a conversion webhook
    4#[derive(Clone, Debug, Default, PartialEq)]
    5pub struct WebhookConversion {
    6    /// clientConfig is the instructions for how to call the webhook if strategy is `Webhook`.
    7    pub client_config: Option<crate::apiextensions_apiserver::pkg::apis::apiextensions::v1::WebhookClientConfig>,
    8
    9    /// conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail.
    10    pub conversion_review_versions: std::vec::Vec<std::string::String>,
    11}
    12
    13impl crate::DeepMerge for WebhookConversion {
    14    fn merge_from(&mut self, other: Self) {
    15        crate::DeepMerge::merge_from(&mut self.client_config, other.client_config);
    16        crate::merge_strategies::list::atomic(&mut self.conversion_review_versions, other.conversion_review_versions);
    17    }
    18}
    19
    20impl<'de> crate::serde::Deserialize<'de> for WebhookConversion {
    21    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    22        #[allow(non_camel_case_types)]
    23        enum Field {
    24            Key_client_config,
    25            Key_conversion_review_versions,
    26            Other,
    27        }
    28
    29        impl<'de> crate::serde::Deserialize<'de> for Field {
    30            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
    31                struct Visitor;
    32
    33                impl crate::serde::de::Visitor<'_> for Visitor {
    34                    type Value = Field;
    35
    36                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    37                        f.write_str("field identifier")
    38                    }
    39
    40                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
    41                        Ok(match v {
    42                            "clientConfig" => Field::Key_client_config,
    43                            "conversionReviewVersions" => Field::Key_conversion_review_versions,
    44                            _ => Field::Other,
    45                        })
    46                    }
    47                }
    48
    49                deserializer.deserialize_identifier(Visitor)
    50            }
    51        }
    52
    53        struct Visitor;
    54
    55        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
    56            type Value = WebhookConversion;
    57
    58            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    59                f.write_str("WebhookConversion")
    60            }
    61
    62            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
    63                let mut value_client_config: Option<crate::apiextensions_apiserver::pkg::apis::apiextensions::v1::WebhookClientConfig> = None;
    64                let mut value_conversion_review_versions: Option<std::vec::Vec<std::string::String>> = None;
    65
    66                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
    67                    match key {
    68                        Field::Key_client_config => value_client_config = crate::serde::de::MapAccess::next_value(&mut map)?,
    69                        Field::Key_conversion_review_versions => value_conversion_review_versions = crate::serde::de::MapAccess::next_value(&mut map)?,
    70                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
    71                    }
    72                }
    73
    74                Ok(WebhookConversion {
    75                    client_config: value_client_config,
    76                    conversion_review_versions: value_conversion_review_versions.unwrap_or_default(),
    77                })
    78            }
    79        }
    80
    81        deserializer.deserialize_struct(
    82            "WebhookConversion",
    83            &[
    84                "clientConfig",
    85                "conversionReviewVersions",
    86            ],
    87            Visitor,
    88        )
    89    }
    90}
    91
    92impl crate::serde::Serialize for WebhookConversion {
    93    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
    94        let mut state = serializer.serialize_struct(
    95            "WebhookConversion",
    96            1 +
    97            self.client_config.as_ref().map_or(0, |_| 1),
    98        )?;
    99        if let Some(value) = &self.client_config {
    100            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "clientConfig", value)?;
    101        }
    102        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "conversionReviewVersions", &self.conversion_review_versions)?;
    103        crate::serde::ser::SerializeStruct::end(state)
    104    }
    105}
    106
    107#[cfg(feature = "schemars")]
    108impl crate::schemars::JsonSchema for WebhookConversion {
    109    fn schema_name() -> std::borrow::Cow<'static, str> {
    110        "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.WebhookConversion".into()
    111    }
    112
    113    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
    114        crate::schemars::json_schema!({
    115            "description": "WebhookConversion describes how to call a conversion webhook",
    116            "type": "object",
    117            "properties": {
    118                "clientConfig": ({
    119                    let mut schema_obj = __gen.subschema_for::<crate::apiextensions_apiserver::pkg::apis::apiextensions::v1::WebhookClientConfig>();
    120                    schema_obj.ensure_object().insert("description".into(), "clientConfig is the instructions for how to call the webhook if strategy is `Webhook`.".into());
    121                    schema_obj
    122                }),
    123                "conversionReviewVersions": {
    124                    "description": "conversionReviewVersions is an ordered list of preferred `ConversionReview` versions the Webhook expects. The API server will use the first version in the list which it supports. If none of the versions specified in this list are supported by API server, conversion will fail for the custom resource. If a persisted Webhook configuration specifies allowed versions and does not include any versions known to the API Server, calls to the webhook will fail.",
    125                    "type": "array",
    126                    "items": {
    127                        "type": "string",
    128                    },
    129                },
    130            },
    131            "required": [
    132                "conversionReviewVersions",
    133            ],
    134        })
    135    }
    136}