#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeploymentSpec {
pub min_ready_seconds: Option<i32>,
pub paused: Option<bool>,
pub progress_deadline_seconds: Option<i32>,
pub replicas: Option<i32>,
pub revision_history_limit: Option<i32>,
pub selector: crate::apimachinery::pkg::apis::meta::v1::LabelSelector,
pub strategy: Option<crate::api::apps::v1::DeploymentStrategy>,
pub template: crate::api::core::v1::PodTemplateSpec,
}
impl crate::DeepMerge for DeploymentSpec {
fn merge_from(&mut self, other: Self) {
crate::DeepMerge::merge_from(&mut self.min_ready_seconds, other.min_ready_seconds);
crate::DeepMerge::merge_from(&mut self.paused, other.paused);
crate::DeepMerge::merge_from(&mut self.progress_deadline_seconds, other.progress_deadline_seconds);
crate::DeepMerge::merge_from(&mut self.replicas, other.replicas);
crate::DeepMerge::merge_from(&mut self.revision_history_limit, other.revision_history_limit);
crate::DeepMerge::merge_from(&mut self.selector, other.selector);
crate::DeepMerge::merge_from(&mut self.strategy, other.strategy);
crate::DeepMerge::merge_from(&mut self.template, other.template);
}
}
impl<'de> crate::serde::Deserialize<'de> for DeploymentSpec {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
#[allow(non_camel_case_types)]
enum Field {
Key_min_ready_seconds,
Key_paused,
Key_progress_deadline_seconds,
Key_replicas,
Key_revision_history_limit,
Key_selector,
Key_strategy,
Key_template,
Other,
}
impl<'de> crate::serde::Deserialize<'de> for Field {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
struct Visitor;
impl crate::serde::de::Visitor<'_> for Visitor {
type Value = Field;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("field identifier")
}
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
Ok(match v {
"minReadySeconds" => Field::Key_min_ready_seconds,
"paused" => Field::Key_paused,
"progressDeadlineSeconds" => Field::Key_progress_deadline_seconds,
"replicas" => Field::Key_replicas,
"revisionHistoryLimit" => Field::Key_revision_history_limit,
"selector" => Field::Key_selector,
"strategy" => Field::Key_strategy,
"template" => Field::Key_template,
_ => Field::Other,
})
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> crate::serde::de::Visitor<'de> for Visitor {
type Value = DeploymentSpec;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("DeploymentSpec")
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
let mut value_min_ready_seconds: Option<i32> = None;
let mut value_paused: Option<bool> = None;
let mut value_progress_deadline_seconds: Option<i32> = None;
let mut value_replicas: Option<i32> = None;
let mut value_revision_history_limit: Option<i32> = None;
let mut value_selector: Option<crate::apimachinery::pkg::apis::meta::v1::LabelSelector> = None;
let mut value_strategy: Option<crate::api::apps::v1::DeploymentStrategy> = None;
let mut value_template: Option<crate::api::core::v1::PodTemplateSpec> = None;
while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
match key {
Field::Key_min_ready_seconds => value_min_ready_seconds = crate::serde::de::MapAccess::next_value(&mut map)?,
Field::Key_paused => value_paused = crate::serde::de::MapAccess::next_value(&mut map)?,
Field::Key_progress_deadline_seconds => value_progress_deadline_seconds = crate::serde::de::MapAccess::next_value(&mut map)?,
Field::Key_replicas => value_replicas = crate::serde::de::MapAccess::next_value(&mut map)?,
Field::Key_revision_history_limit => value_revision_history_limit = crate::serde::de::MapAccess::next_value(&mut map)?,
Field::Key_selector => value_selector = crate::serde::de::MapAccess::next_value(&mut map)?,
Field::Key_strategy => value_strategy = crate::serde::de::MapAccess::next_value(&mut map)?,
Field::Key_template => value_template = crate::serde::de::MapAccess::next_value(&mut map)?,
Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
}
}
Ok(DeploymentSpec {
min_ready_seconds: value_min_ready_seconds,
paused: value_paused,
progress_deadline_seconds: value_progress_deadline_seconds,
replicas: value_replicas,
revision_history_limit: value_revision_history_limit,
selector: value_selector.unwrap_or_default(),
strategy: value_strategy,
template: value_template.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"DeploymentSpec",
&[
"minReadySeconds",
"paused",
"progressDeadlineSeconds",
"replicas",
"revisionHistoryLimit",
"selector",
"strategy",
"template",
],
Visitor,
)
}
}
impl crate::serde::Serialize for DeploymentSpec {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
let mut state = serializer.serialize_struct(
"DeploymentSpec",
2 +
self.min_ready_seconds.as_ref().map_or(0, |_| 1) +
self.paused.as_ref().map_or(0, |_| 1) +
self.progress_deadline_seconds.as_ref().map_or(0, |_| 1) +
self.replicas.as_ref().map_or(0, |_| 1) +
self.revision_history_limit.as_ref().map_or(0, |_| 1) +
self.strategy.as_ref().map_or(0, |_| 1),
)?;
if let Some(value) = &self.min_ready_seconds {
crate::serde::ser::SerializeStruct::serialize_field(&mut state, "minReadySeconds", value)?;
}
if let Some(value) = &self.paused {
crate::serde::ser::SerializeStruct::serialize_field(&mut state, "paused", value)?;
}
if let Some(value) = &self.progress_deadline_seconds {
crate::serde::ser::SerializeStruct::serialize_field(&mut state, "progressDeadlineSeconds", value)?;
}
if let Some(value) = &self.replicas {
crate::serde::ser::SerializeStruct::serialize_field(&mut state, "replicas", value)?;
}
if let Some(value) = &self.revision_history_limit {
crate::serde::ser::SerializeStruct::serialize_field(&mut state, "revisionHistoryLimit", value)?;
}
crate::serde::ser::SerializeStruct::serialize_field(&mut state, "selector", &self.selector)?;
if let Some(value) = &self.strategy {
crate::serde::ser::SerializeStruct::serialize_field(&mut state, "strategy", value)?;
}
crate::serde::ser::SerializeStruct::serialize_field(&mut state, "template", &self.template)?;
crate::serde::ser::SerializeStruct::end(state)
}
}
#[cfg(feature = "schemars")]
impl crate::schemars::JsonSchema for DeploymentSpec {
fn schema_name() -> std::borrow::Cow<'static, str> {
"io.k8s.api.apps.v1.DeploymentSpec".into()
}
fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
crate::schemars::json_schema!({
"description": "DeploymentSpec is the specification of the desired behavior of the Deployment.",
"type": "object",
"properties": {
"minReadySeconds": {
"description": "Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready)",
"type": "integer",
"format": "int32",
},
"paused": {
"description": "Indicates that the deployment is paused.",
"type": "boolean",
},
"progressDeadlineSeconds": {
"description": "The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s.",
"type": "integer",
"format": "int32",
},
"replicas": {
"description": "Number of desired pods. This is a pointer to distinguish between explicit zero and not specified. Defaults to 1.",
"type": "integer",
"format": "int32",
},
"revisionHistoryLimit": {
"description": "The number of old ReplicaSets to retain to allow rollback. This is a pointer to distinguish between explicit zero and not specified. Defaults to 10.",
"type": "integer",
"format": "int32",
},
"selector": ({
let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::LabelSelector>();
schema_obj.ensure_object().insert("description".into(), "Label selector for pods. Existing ReplicaSets whose pods are selected by this will be the ones affected by this deployment. It must match the pod template's labels.".into());
schema_obj
}),
"strategy": ({
let mut schema_obj = __gen.subschema_for::<crate::api::apps::v1::DeploymentStrategy>();
schema_obj.ensure_object().insert("description".into(), "The deployment strategy to use to replace existing pods with new ones.".into());
schema_obj
}),
"template": ({
let mut schema_obj = __gen.subschema_for::<crate::api::core::v1::PodTemplateSpec>();
schema_obj.ensure_object().insert("description".into(), "Template describes the pods that will be created. The only allowed template.spec.restartPolicy value is \"Always\".".into());
schema_obj
}),
},
"required": [
"selector",
"template",
],
})
}
}