#[derive(Clone, Debug, Default, PartialEq)]
pub struct PodSpec {
pub active_deadline_seconds: Option<i64>,
pub affinity: Option<crate::v1_13::api::core::v1::Affinity>,
pub automount_service_account_token: Option<bool>,
pub containers: Vec<crate::v1_13::api::core::v1::Container>,
pub dns_config: Option<crate::v1_13::api::core::v1::PodDNSConfig>,
pub dns_policy: Option<String>,
pub enable_service_links: Option<bool>,
pub host_aliases: Option<Vec<crate::v1_13::api::core::v1::HostAlias>>,
pub host_ipc: Option<bool>,
pub host_network: Option<bool>,
pub host_pid: Option<bool>,
pub hostname: Option<String>,
pub image_pull_secrets: Option<Vec<crate::v1_13::api::core::v1::LocalObjectReference>>,
pub init_containers: Option<Vec<crate::v1_13::api::core::v1::Container>>,
pub node_name: Option<String>,
pub node_selector: Option<std::collections::BTreeMap<String, String>>,
pub priority: Option<i32>,
pub priority_class_name: Option<String>,
pub readiness_gates: Option<Vec<crate::v1_13::api::core::v1::PodReadinessGate>>,
pub restart_policy: Option<String>,
pub runtime_class_name: Option<String>,
pub scheduler_name: Option<String>,
pub security_context: Option<crate::v1_13::api::core::v1::PodSecurityContext>,
pub service_account: Option<String>,
pub service_account_name: Option<String>,
pub share_process_namespace: Option<bool>,
pub subdomain: Option<String>,
pub termination_grace_period_seconds: Option<i64>,
pub tolerations: Option<Vec<crate::v1_13::api::core::v1::Toleration>>,
pub volumes: Option<Vec<crate::v1_13::api::core::v1::Volume>>,
}
impl<'de> serde::Deserialize<'de> for PodSpec {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
#[allow(non_camel_case_types)]
enum Field {
Key_active_deadline_seconds,
Key_affinity,
Key_automount_service_account_token,
Key_containers,
Key_dns_config,
Key_dns_policy,
Key_enable_service_links,
Key_host_aliases,
Key_host_ipc,
Key_host_network,
Key_host_pid,
Key_hostname,
Key_image_pull_secrets,
Key_init_containers,
Key_node_name,
Key_node_selector,
Key_priority,
Key_priority_class_name,
Key_readiness_gates,
Key_restart_policy,
Key_runtime_class_name,
Key_scheduler_name,
Key_security_context,
Key_service_account,
Key_service_account_name,
Key_share_process_namespace,
Key_subdomain,
Key_termination_grace_period_seconds,
Key_tolerations,
Key_volumes,
Other,
}
impl<'de> serde::Deserialize<'de> for Field {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = Field;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "field identifier")
}
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
Ok(match v {
"activeDeadlineSeconds" => Field::Key_active_deadline_seconds,
"affinity" => Field::Key_affinity,
"automountServiceAccountToken" => Field::Key_automount_service_account_token,
"containers" => Field::Key_containers,
"dnsConfig" => Field::Key_dns_config,
"dnsPolicy" => Field::Key_dns_policy,
"enableServiceLinks" => Field::Key_enable_service_links,
"hostAliases" => Field::Key_host_aliases,
"hostIPC" => Field::Key_host_ipc,
"hostNetwork" => Field::Key_host_network,
"hostPID" => Field::Key_host_pid,
"hostname" => Field::Key_hostname,
"imagePullSecrets" => Field::Key_image_pull_secrets,
"initContainers" => Field::Key_init_containers,
"nodeName" => Field::Key_node_name,
"nodeSelector" => Field::Key_node_selector,
"priority" => Field::Key_priority,
"priorityClassName" => Field::Key_priority_class_name,
"readinessGates" => Field::Key_readiness_gates,
"restartPolicy" => Field::Key_restart_policy,
"runtimeClassName" => Field::Key_runtime_class_name,
"schedulerName" => Field::Key_scheduler_name,
"securityContext" => Field::Key_security_context,
"serviceAccount" => Field::Key_service_account,
"serviceAccountName" => Field::Key_service_account_name,
"shareProcessNamespace" => Field::Key_share_process_namespace,
"subdomain" => Field::Key_subdomain,
"terminationGracePeriodSeconds" => Field::Key_termination_grace_period_seconds,
"tolerations" => Field::Key_tolerations,
"volumes" => Field::Key_volumes,
_ => Field::Other,
})
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = PodSpec;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "struct PodSpec")
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
let mut value_active_deadline_seconds: Option<i64> = None;
let mut value_affinity: Option<crate::v1_13::api::core::v1::Affinity> = None;
let mut value_automount_service_account_token: Option<bool> = None;
let mut value_containers: Option<Vec<crate::v1_13::api::core::v1::Container>> = None;
let mut value_dns_config: Option<crate::v1_13::api::core::v1::PodDNSConfig> = None;
let mut value_dns_policy: Option<String> = None;
let mut value_enable_service_links: Option<bool> = None;
let mut value_host_aliases: Option<Vec<crate::v1_13::api::core::v1::HostAlias>> = None;
let mut value_host_ipc: Option<bool> = None;
let mut value_host_network: Option<bool> = None;
let mut value_host_pid: Option<bool> = None;
let mut value_hostname: Option<String> = None;
let mut value_image_pull_secrets: Option<Vec<crate::v1_13::api::core::v1::LocalObjectReference>> = None;
let mut value_init_containers: Option<Vec<crate::v1_13::api::core::v1::Container>> = None;
let mut value_node_name: Option<String> = None;
let mut value_node_selector: Option<std::collections::BTreeMap<String, String>> = None;
let mut value_priority: Option<i32> = None;
let mut value_priority_class_name: Option<String> = None;
let mut value_readiness_gates: Option<Vec<crate::v1_13::api::core::v1::PodReadinessGate>> = None;
let mut value_restart_policy: Option<String> = None;
let mut value_runtime_class_name: Option<String> = None;
let mut value_scheduler_name: Option<String> = None;
let mut value_security_context: Option<crate::v1_13::api::core::v1::PodSecurityContext> = None;
let mut value_service_account: Option<String> = None;
let mut value_service_account_name: Option<String> = None;
let mut value_share_process_namespace: Option<bool> = None;
let mut value_subdomain: Option<String> = None;
let mut value_termination_grace_period_seconds: Option<i64> = None;
let mut value_tolerations: Option<Vec<crate::v1_13::api::core::v1::Toleration>> = None;
let mut value_volumes: Option<Vec<crate::v1_13::api::core::v1::Volume>> = None;
while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
match key {
Field::Key_active_deadline_seconds => value_active_deadline_seconds = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_affinity => value_affinity = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_automount_service_account_token => value_automount_service_account_token = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_containers => value_containers = Some(serde::de::MapAccess::next_value(&mut map)?),
Field::Key_dns_config => value_dns_config = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_dns_policy => value_dns_policy = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_enable_service_links => value_enable_service_links = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_host_aliases => value_host_aliases = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_host_ipc => value_host_ipc = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_host_network => value_host_network = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_host_pid => value_host_pid = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_hostname => value_hostname = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_image_pull_secrets => value_image_pull_secrets = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_init_containers => value_init_containers = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_node_name => value_node_name = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_node_selector => value_node_selector = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_priority => value_priority = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_priority_class_name => value_priority_class_name = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_readiness_gates => value_readiness_gates = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_restart_policy => value_restart_policy = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_runtime_class_name => value_runtime_class_name = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_scheduler_name => value_scheduler_name = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_security_context => value_security_context = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_service_account => value_service_account = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_service_account_name => value_service_account_name = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_share_process_namespace => value_share_process_namespace = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_subdomain => value_subdomain = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_termination_grace_period_seconds => value_termination_grace_period_seconds = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_tolerations => value_tolerations = serde::de::MapAccess::next_value(&mut map)?,
Field::Key_volumes => value_volumes = serde::de::MapAccess::next_value(&mut map)?,
Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
}
}
Ok(PodSpec {
active_deadline_seconds: value_active_deadline_seconds,
affinity: value_affinity,
automount_service_account_token: value_automount_service_account_token,
containers: value_containers.ok_or_else(|| serde::de::Error::missing_field("containers"))?,
dns_config: value_dns_config,
dns_policy: value_dns_policy,
enable_service_links: value_enable_service_links,
host_aliases: value_host_aliases,
host_ipc: value_host_ipc,
host_network: value_host_network,
host_pid: value_host_pid,
hostname: value_hostname,
image_pull_secrets: value_image_pull_secrets,
init_containers: value_init_containers,
node_name: value_node_name,
node_selector: value_node_selector,
priority: value_priority,
priority_class_name: value_priority_class_name,
readiness_gates: value_readiness_gates,
restart_policy: value_restart_policy,
runtime_class_name: value_runtime_class_name,
scheduler_name: value_scheduler_name,
security_context: value_security_context,
service_account: value_service_account,
service_account_name: value_service_account_name,
share_process_namespace: value_share_process_namespace,
subdomain: value_subdomain,
termination_grace_period_seconds: value_termination_grace_period_seconds,
tolerations: value_tolerations,
volumes: value_volumes,
})
}
}
deserializer.deserialize_struct(
"PodSpec",
&[
"activeDeadlineSeconds",
"affinity",
"automountServiceAccountToken",
"containers",
"dnsConfig",
"dnsPolicy",
"enableServiceLinks",
"hostAliases",
"hostIPC",
"hostNetwork",
"hostPID",
"hostname",
"imagePullSecrets",
"initContainers",
"nodeName",
"nodeSelector",
"priority",
"priorityClassName",
"readinessGates",
"restartPolicy",
"runtimeClassName",
"schedulerName",
"securityContext",
"serviceAccount",
"serviceAccountName",
"shareProcessNamespace",
"subdomain",
"terminationGracePeriodSeconds",
"tolerations",
"volumes",
],
Visitor,
)
}
}
impl serde::Serialize for PodSpec {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
let mut state = serializer.serialize_struct(
"PodSpec",
1 +
self.active_deadline_seconds.as_ref().map_or(0, |_| 1) +
self.affinity.as_ref().map_or(0, |_| 1) +
self.automount_service_account_token.as_ref().map_or(0, |_| 1) +
self.dns_config.as_ref().map_or(0, |_| 1) +
self.dns_policy.as_ref().map_or(0, |_| 1) +
self.enable_service_links.as_ref().map_or(0, |_| 1) +
self.host_aliases.as_ref().map_or(0, |_| 1) +
self.host_ipc.as_ref().map_or(0, |_| 1) +
self.host_network.as_ref().map_or(0, |_| 1) +
self.host_pid.as_ref().map_or(0, |_| 1) +
self.hostname.as_ref().map_or(0, |_| 1) +
self.image_pull_secrets.as_ref().map_or(0, |_| 1) +
self.init_containers.as_ref().map_or(0, |_| 1) +
self.node_name.as_ref().map_or(0, |_| 1) +
self.node_selector.as_ref().map_or(0, |_| 1) +
self.priority.as_ref().map_or(0, |_| 1) +
self.priority_class_name.as_ref().map_or(0, |_| 1) +
self.readiness_gates.as_ref().map_or(0, |_| 1) +
self.restart_policy.as_ref().map_or(0, |_| 1) +
self.runtime_class_name.as_ref().map_or(0, |_| 1) +
self.scheduler_name.as_ref().map_or(0, |_| 1) +
self.security_context.as_ref().map_or(0, |_| 1) +
self.service_account.as_ref().map_or(0, |_| 1) +
self.service_account_name.as_ref().map_or(0, |_| 1) +
self.share_process_namespace.as_ref().map_or(0, |_| 1) +
self.subdomain.as_ref().map_or(0, |_| 1) +
self.termination_grace_period_seconds.as_ref().map_or(0, |_| 1) +
self.tolerations.as_ref().map_or(0, |_| 1) +
self.volumes.as_ref().map_or(0, |_| 1),
)?;
if let Some(value) = &self.active_deadline_seconds {
serde::ser::SerializeStruct::serialize_field(&mut state, "activeDeadlineSeconds", value)?;
}
if let Some(value) = &self.affinity {
serde::ser::SerializeStruct::serialize_field(&mut state, "affinity", value)?;
}
if let Some(value) = &self.automount_service_account_token {
serde::ser::SerializeStruct::serialize_field(&mut state, "automountServiceAccountToken", value)?;
}
serde::ser::SerializeStruct::serialize_field(&mut state, "containers", &self.containers)?;
if let Some(value) = &self.dns_config {
serde::ser::SerializeStruct::serialize_field(&mut state, "dnsConfig", value)?;
}
if let Some(value) = &self.dns_policy {
serde::ser::SerializeStruct::serialize_field(&mut state, "dnsPolicy", value)?;
}
if let Some(value) = &self.enable_service_links {
serde::ser::SerializeStruct::serialize_field(&mut state, "enableServiceLinks", value)?;
}
if let Some(value) = &self.host_aliases {
serde::ser::SerializeStruct::serialize_field(&mut state, "hostAliases", value)?;
}
if let Some(value) = &self.host_ipc {
serde::ser::SerializeStruct::serialize_field(&mut state, "hostIPC", value)?;
}
if let Some(value) = &self.host_network {
serde::ser::SerializeStruct::serialize_field(&mut state, "hostNetwork", value)?;
}
if let Some(value) = &self.host_pid {
serde::ser::SerializeStruct::serialize_field(&mut state, "hostPID", value)?;
}
if let Some(value) = &self.hostname {
serde::ser::SerializeStruct::serialize_field(&mut state, "hostname", value)?;
}
if let Some(value) = &self.image_pull_secrets {
serde::ser::SerializeStruct::serialize_field(&mut state, "imagePullSecrets", value)?;
}
if let Some(value) = &self.init_containers {
serde::ser::SerializeStruct::serialize_field(&mut state, "initContainers", value)?;
}
if let Some(value) = &self.node_name {
serde::ser::SerializeStruct::serialize_field(&mut state, "nodeName", value)?;
}
if let Some(value) = &self.node_selector {
serde::ser::SerializeStruct::serialize_field(&mut state, "nodeSelector", value)?;
}
if let Some(value) = &self.priority {
serde::ser::SerializeStruct::serialize_field(&mut state, "priority", value)?;
}
if let Some(value) = &self.priority_class_name {
serde::ser::SerializeStruct::serialize_field(&mut state, "priorityClassName", value)?;
}
if let Some(value) = &self.readiness_gates {
serde::ser::SerializeStruct::serialize_field(&mut state, "readinessGates", value)?;
}
if let Some(value) = &self.restart_policy {
serde::ser::SerializeStruct::serialize_field(&mut state, "restartPolicy", value)?;
}
if let Some(value) = &self.runtime_class_name {
serde::ser::SerializeStruct::serialize_field(&mut state, "runtimeClassName", value)?;
}
if let Some(value) = &self.scheduler_name {
serde::ser::SerializeStruct::serialize_field(&mut state, "schedulerName", value)?;
}
if let Some(value) = &self.security_context {
serde::ser::SerializeStruct::serialize_field(&mut state, "securityContext", value)?;
}
if let Some(value) = &self.service_account {
serde::ser::SerializeStruct::serialize_field(&mut state, "serviceAccount", value)?;
}
if let Some(value) = &self.service_account_name {
serde::ser::SerializeStruct::serialize_field(&mut state, "serviceAccountName", value)?;
}
if let Some(value) = &self.share_process_namespace {
serde::ser::SerializeStruct::serialize_field(&mut state, "shareProcessNamespace", value)?;
}
if let Some(value) = &self.subdomain {
serde::ser::SerializeStruct::serialize_field(&mut state, "subdomain", value)?;
}
if let Some(value) = &self.termination_grace_period_seconds {
serde::ser::SerializeStruct::serialize_field(&mut state, "terminationGracePeriodSeconds", value)?;
}
if let Some(value) = &self.tolerations {
serde::ser::SerializeStruct::serialize_field(&mut state, "tolerations", value)?;
}
if let Some(value) = &self.volumes {
serde::ser::SerializeStruct::serialize_field(&mut state, "volumes", value)?;
}
serde::ser::SerializeStruct::end(state)
}
}