From fe0aafd0212b0c058d61e2cc8301f4828ee74a72 Mon Sep 17 00:00:00 2001 From: Benjamin Leggett Date: Thu, 23 Apr 2026 13:01:45 -0400 Subject: [PATCH] Bump versions and rust ver --- Cargo.toml | 8 +- Containerfile | 2 +- .../protect/control/v1/protect.control.v1.rs | 34 +- .../control/v1/protect.control.v1.serde.rs | 429 +++++++++++++++++- 4 files changed, 462 insertions(+), 11 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 19309b4..59587c6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,12 +24,12 @@ exclude = [ # to produce usable `.so` binaries. # # See: https://github.com/rust-lang/rust/issues/59302 for details. -# +# # RUSTFLAGS="-C target-feature=-crt-static" is a bad workaround, # because when used with a musl target it not only results in # a non-loadable plugin binary, it applies to the other crates # in the workspace as well, which we do not want. -# +# # To hack around this for dev builds, we specify multiple crate types: # `rlib` and `cdylib`. If you specify just `cdylib`, `musl` target builds # will error out. If you specify both types, then `musl` target builds will @@ -41,7 +41,7 @@ crate-type = ["rlib", "cdylib"] anyhow = "1.0.102" async-stream = "0.3.6" aya = "0.14" -caps = "0.5.5" +caps = "0.5.6" dns-lookup = "3.0.1" falco_plugin = { version = "0.5.1" } falco_plugin_api = { version = "0.5.1" } @@ -64,5 +64,5 @@ url = "2.5.8" uuid = { version = "1.23.1", features = ["v4"] } pbjson = "0.9.0" pbjson-types = "0.9.0" -serde = { version = "1.0.219", features = ["derive"] } +serde = { version = "1.0.228", features = ["derive"] } tonic-prost = { version = "0.14.6" } diff --git a/Containerfile b/Containerfile index fb83d5b..785399b 100644 --- a/Containerfile +++ b/Containerfile @@ -1,5 +1,5 @@ # This is *not* sha-locked as ghcr doesn't have arch-agnostic SHAs ATM, AFAICT. -FROM rust:1.92-bookworm AS build +FROM rust:1.95-trixie AS build RUN apt-get update && apt-get --assume-yes install protobuf-compiler git clang cmake build-essential llvm-dev libclang-dev jq diff --git a/src/proto/generated/protect/control/v1/protect.control.v1.rs b/src/proto/generated/protect/control/v1/protect.control.v1.rs index 8cc4165..aa34911 100644 --- a/src/proto/generated/protect/control/v1/protect.control.v1.rs +++ b/src/proto/generated/protect/control/v1/protect.control.v1.rs @@ -154,6 +154,8 @@ pub struct ProcessSpec { pub stdout: bool, #[prost(bool, tag="10")] pub stderr: bool, + #[prost(int64, repeated, tag="13")] + pub additional_gids: ::prost::alloc::vec::Vec, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct MountSpec { @@ -191,6 +193,11 @@ pub struct WorkloadBlockDeviceSpec { pub mount_options: ::core::option::Option, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct WorkloadPciDeviceSpec { + #[prost(string, tag="1")] + pub location: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct BlockDeviceMountOptions { #[prost(bool, tag="1")] pub readonly: bool, @@ -401,6 +408,10 @@ pub struct WorkloadSpec { pub hostname: ::prost::alloc::string::String, #[prost(message, repeated, tag="11")] pub block_devices: ::prost::alloc::vec::Vec, + #[prost(int32, optional, tag="12")] + pub oom_score_adj: ::core::option::Option, + #[prost(message, repeated, tag="13")] + pub pci_devices: ::prost::alloc::vec::Vec, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct CgroupLimit { @@ -449,6 +460,8 @@ pub struct WorkloadStatus { pub mount_status: ::core::option::Option, #[prost(message, optional, tag="6")] pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, + #[prost(message, optional, tag="7")] + pub pci_device_status: ::core::option::Option, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct WorkloadBlockDeviceInfo { @@ -461,11 +474,21 @@ pub struct WorkloadBlockDeviceInfo { #[prost(bool, tag="5")] pub loop_dev: bool, } +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct WorkloadPciDeviceInfo { + #[prost(string, tag="1")] + pub location: ::prost::alloc::string::String, +} #[derive(Clone, PartialEq, ::prost::Message)] pub struct WorkloadBlockDeviceStatus { #[prost(message, repeated, tag="1")] pub devices: ::prost::alloc::vec::Vec, } +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorkloadPciDeviceStatus { + #[prost(message, repeated, tag="1")] + pub devices: ::prost::alloc::vec::Vec, +} #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct WorkloadMountInfo { #[prost(string, tag="2")] @@ -828,7 +851,6 @@ pub enum ZoneState { Creating = 1, Created = 2, Ready = 3, - Exited = 4, Destroying = 5, Destroyed = 6, Failed = 7, @@ -844,7 +866,6 @@ impl ZoneState { Self::Creating => "ZONE_STATE_CREATING", Self::Created => "ZONE_STATE_CREATED", Self::Ready => "ZONE_STATE_READY", - Self::Exited => "ZONE_STATE_EXITED", Self::Destroying => "ZONE_STATE_DESTROYING", Self::Destroyed => "ZONE_STATE_DESTROYED", Self::Failed => "ZONE_STATE_FAILED", @@ -857,7 +878,6 @@ impl ZoneState { "ZONE_STATE_CREATING" => Some(Self::Creating), "ZONE_STATE_CREATED" => Some(Self::Created), "ZONE_STATE_READY" => Some(Self::Ready), - "ZONE_STATE_EXITED" => Some(Self::Exited), "ZONE_STATE_DESTROYING" => Some(Self::Destroying), "ZONE_STATE_DESTROYED" => Some(Self::Destroyed), "ZONE_STATE_FAILED" => Some(Self::Failed), @@ -1206,6 +1226,14 @@ pub struct GetHostStatusReply { pub host_mac: ::prost::alloc::string::String, #[prost(uint64, optional, tag="7")] pub hyp_free_mem: ::core::option::Option, + #[prost(string, optional, tag="8")] + pub protect_git_sha: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, optional, tag="9")] + pub protect_last_tag: ::core::option::Option<::prost::alloc::string::String>, + #[prost(uint64, optional, tag="10")] + pub protect_revs_since_tag: ::core::option::Option, + #[prost(string, optional, tag="11")] + pub protect_branch: ::core::option::Option<::prost::alloc::string::String>, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateZoneRequest { diff --git a/src/proto/generated/protect/control/v1/protect.control.v1.serde.rs b/src/proto/generated/protect/control/v1/protect.control.v1.serde.rs index d8d5d01..0d2286b 100644 --- a/src/proto/generated/protect/control/v1/protect.control.v1.serde.rs +++ b/src/proto/generated/protect/control/v1/protect.control.v1.serde.rs @@ -3232,6 +3232,18 @@ impl serde::Serialize for GetHostStatusReply { if self.hyp_free_mem.is_some() { len += 1; } + if self.protect_git_sha.is_some() { + len += 1; + } + if self.protect_last_tag.is_some() { + len += 1; + } + if self.protect_revs_since_tag.is_some() { + len += 1; + } + if self.protect_branch.is_some() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetHostStatusReply", len)?; if !self.host_uuid.is_empty() { struct_ser.serialize_field("hostUuid", &self.host_uuid)?; @@ -3256,6 +3268,20 @@ impl serde::Serialize for GetHostStatusReply { #[allow(clippy::needless_borrows_for_generic_args)] struct_ser.serialize_field("hypFreeMem", ToString::to_string(&v).as_str())?; } + if let Some(v) = self.protect_git_sha.as_ref() { + struct_ser.serialize_field("protectGitSha", v)?; + } + if let Some(v) = self.protect_last_tag.as_ref() { + struct_ser.serialize_field("protectLastTag", v)?; + } + if let Some(v) = self.protect_revs_since_tag.as_ref() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("protectRevsSinceTag", ToString::to_string(&v).as_str())?; + } + if let Some(v) = self.protect_branch.as_ref() { + struct_ser.serialize_field("protectBranch", v)?; + } struct_ser.end() } } @@ -3280,6 +3306,14 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusReply { "hostMac", "hyp_free_mem", "hypFreeMem", + "protect_git_sha", + "protectGitSha", + "protect_last_tag", + "protectLastTag", + "protect_revs_since_tag", + "protectRevsSinceTag", + "protect_branch", + "protectBranch", ]; #[allow(clippy::enum_variant_names)] @@ -3291,6 +3325,10 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusReply { HostIpv6, HostMac, HypFreeMem, + ProtectGitSha, + ProtectLastTag, + ProtectRevsSinceTag, + ProtectBranch, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3319,6 +3357,10 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusReply { "hostIpv6" | "host_ipv6" => Ok(GeneratedField::HostIpv6), "hostMac" | "host_mac" => Ok(GeneratedField::HostMac), "hypFreeMem" | "hyp_free_mem" => Ok(GeneratedField::HypFreeMem), + "protectGitSha" | "protect_git_sha" => Ok(GeneratedField::ProtectGitSha), + "protectLastTag" | "protect_last_tag" => Ok(GeneratedField::ProtectLastTag), + "protectRevsSinceTag" | "protect_revs_since_tag" => Ok(GeneratedField::ProtectRevsSinceTag), + "protectBranch" | "protect_branch" => Ok(GeneratedField::ProtectBranch), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3345,6 +3387,10 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusReply { let mut host_ipv6__ = None; let mut host_mac__ = None; let mut hyp_free_mem__ = None; + let mut protect_git_sha__ = None; + let mut protect_last_tag__ = None; + let mut protect_revs_since_tag__ = None; + let mut protect_branch__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::HostUuid => { @@ -3393,6 +3439,32 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusReply { map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) ; } + GeneratedField::ProtectGitSha => { + if protect_git_sha__.is_some() { + return Err(serde::de::Error::duplicate_field("protectGitSha")); + } + protect_git_sha__ = map_.next_value()?; + } + GeneratedField::ProtectLastTag => { + if protect_last_tag__.is_some() { + return Err(serde::de::Error::duplicate_field("protectLastTag")); + } + protect_last_tag__ = map_.next_value()?; + } + GeneratedField::ProtectRevsSinceTag => { + if protect_revs_since_tag__.is_some() { + return Err(serde::de::Error::duplicate_field("protectRevsSinceTag")); + } + protect_revs_since_tag__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::ProtectBranch => { + if protect_branch__.is_some() { + return Err(serde::de::Error::duplicate_field("protectBranch")); + } + protect_branch__ = map_.next_value()?; + } } } Ok(GetHostStatusReply { @@ -3403,6 +3475,10 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusReply { host_ipv6: host_ipv6__.unwrap_or_default(), host_mac: host_mac__.unwrap_or_default(), hyp_free_mem: hyp_free_mem__, + protect_git_sha: protect_git_sha__, + protect_last_tag: protect_last_tag__, + protect_revs_since_tag: protect_revs_since_tag__, + protect_branch: protect_branch__, }) } } @@ -8501,6 +8577,9 @@ impl serde::Serialize for ProcessSpec { if self.stderr { len += 1; } + if !self.additional_gids.is_empty() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("protect.control.v1.ProcessSpec", len)?; if !self.environment.is_empty() { struct_ser.serialize_field("environment", &self.environment)?; @@ -8532,6 +8611,9 @@ impl serde::Serialize for ProcessSpec { if self.stderr { struct_ser.serialize_field("stderr", &self.stderr)?; } + if !self.additional_gids.is_empty() { + struct_ser.serialize_field("additionalGids", &self.additional_gids.iter().map(ToString::to_string).collect::>())?; + } struct_ser.end() } } @@ -8554,6 +8636,8 @@ impl<'de> serde::Deserialize<'de> for ProcessSpec { "stdin", "stdout", "stderr", + "additional_gids", + "additionalGids", ]; #[allow(clippy::enum_variant_names)] @@ -8568,6 +8652,7 @@ impl<'de> serde::Deserialize<'de> for ProcessSpec { Stdin, Stdout, Stderr, + AdditionalGids, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8599,6 +8684,7 @@ impl<'de> serde::Deserialize<'de> for ProcessSpec { "stdin" => Ok(GeneratedField::Stdin), "stdout" => Ok(GeneratedField::Stdout), "stderr" => Ok(GeneratedField::Stderr), + "additionalGids" | "additional_gids" => Ok(GeneratedField::AdditionalGids), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8628,6 +8714,7 @@ impl<'de> serde::Deserialize<'de> for ProcessSpec { let mut stdin__ = None; let mut stdout__ = None; let mut stderr__ = None; + let mut additional_gids__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Environment => { @@ -8690,6 +8777,15 @@ impl<'de> serde::Deserialize<'de> for ProcessSpec { } stderr__ = Some(map_.next_value()?); } + GeneratedField::AdditionalGids => { + if additional_gids__.is_some() { + return Err(serde::de::Error::duplicate_field("additionalGids")); + } + additional_gids__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } } } Ok(ProcessSpec { @@ -8703,6 +8799,7 @@ impl<'de> serde::Deserialize<'de> for ProcessSpec { stdin: stdin__.unwrap_or_default(), stdout: stdout__.unwrap_or_default(), stderr: stderr__.unwrap_or_default(), + additional_gids: additional_gids__.unwrap_or_default(), }) } } @@ -12858,6 +12955,279 @@ impl<'de> serde::Deserialize<'de> for WorkloadMountStatus { deserializer.deserialize_struct("protect.control.v1.WorkloadMountStatus", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for WorkloadPciDeviceInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.location.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadPciDeviceInfo", len)?; + if !self.location.is_empty() { + struct_ser.serialize_field("location", &self.location)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "location", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Location, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "location" => Ok(GeneratedField::Location), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadPciDeviceInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadPciDeviceInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut location__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Location => { + if location__.is_some() { + return Err(serde::de::Error::duplicate_field("location")); + } + location__ = Some(map_.next_value()?); + } + } + } + Ok(WorkloadPciDeviceInfo { + location: location__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadPciDeviceInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadPciDeviceSpec { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.location.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadPciDeviceSpec", len)?; + if !self.location.is_empty() { + struct_ser.serialize_field("location", &self.location)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceSpec { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "location", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Location, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "location" => Ok(GeneratedField::Location), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadPciDeviceSpec; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadPciDeviceSpec") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut location__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Location => { + if location__.is_some() { + return Err(serde::de::Error::duplicate_field("location")); + } + location__ = Some(map_.next_value()?); + } + } + } + Ok(WorkloadPciDeviceSpec { + location: location__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadPciDeviceSpec", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadPciDeviceStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.devices.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadPciDeviceStatus", len)?; + if !self.devices.is_empty() { + struct_ser.serialize_field("devices", &self.devices)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "devices", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Devices, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "devices" => Ok(GeneratedField::Devices), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadPciDeviceStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadPciDeviceStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut devices__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Devices => { + if devices__.is_some() { + return Err(serde::de::Error::duplicate_field("devices")); + } + devices__ = Some(map_.next_value()?); + } + } + } + Ok(WorkloadPciDeviceStatus { + devices: devices__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadPciDeviceStatus", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for WorkloadScratchMount { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -13229,6 +13599,12 @@ impl serde::Serialize for WorkloadSpec { if !self.block_devices.is_empty() { len += 1; } + if self.oom_score_adj.is_some() { + len += 1; + } + if !self.pci_devices.is_empty() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadSpec", len)?; if !self.name.is_empty() { struct_ser.serialize_field("name", &self.name)?; @@ -13263,6 +13639,12 @@ impl serde::Serialize for WorkloadSpec { if !self.block_devices.is_empty() { struct_ser.serialize_field("blockDevices", &self.block_devices)?; } + if let Some(v) = self.oom_score_adj.as_ref() { + struct_ser.serialize_field("oomScoreAdj", v)?; + } + if !self.pci_devices.is_empty() { + struct_ser.serialize_field("pciDevices", &self.pci_devices)?; + } struct_ser.end() } } @@ -13288,6 +13670,10 @@ impl<'de> serde::Deserialize<'de> for WorkloadSpec { "hostname", "block_devices", "blockDevices", + "oom_score_adj", + "oomScoreAdj", + "pci_devices", + "pciDevices", ]; #[allow(clippy::enum_variant_names)] @@ -13303,6 +13689,8 @@ impl<'de> serde::Deserialize<'de> for WorkloadSpec { CgroupLimits, Hostname, BlockDevices, + OomScoreAdj, + PciDevices, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -13335,6 +13723,8 @@ impl<'de> serde::Deserialize<'de> for WorkloadSpec { "cgroupLimits" | "cgroup_limits" => Ok(GeneratedField::CgroupLimits), "hostname" => Ok(GeneratedField::Hostname), "blockDevices" | "block_devices" => Ok(GeneratedField::BlockDevices), + "oomScoreAdj" | "oom_score_adj" => Ok(GeneratedField::OomScoreAdj), + "pciDevices" | "pci_devices" => Ok(GeneratedField::PciDevices), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -13365,6 +13755,8 @@ impl<'de> serde::Deserialize<'de> for WorkloadSpec { let mut cgroup_limits__ = None; let mut hostname__ = None; let mut block_devices__ = None; + let mut oom_score_adj__ = None; + let mut pci_devices__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Name => { @@ -13433,6 +13825,20 @@ impl<'de> serde::Deserialize<'de> for WorkloadSpec { } block_devices__ = Some(map_.next_value()?); } + GeneratedField::OomScoreAdj => { + if oom_score_adj__.is_some() { + return Err(serde::de::Error::duplicate_field("oomScoreAdj")); + } + oom_score_adj__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::PciDevices => { + if pci_devices__.is_some() { + return Err(serde::de::Error::duplicate_field("pciDevices")); + } + pci_devices__ = Some(map_.next_value()?); + } } } Ok(WorkloadSpec { @@ -13447,6 +13853,8 @@ impl<'de> serde::Deserialize<'de> for WorkloadSpec { cgroup_limits: cgroup_limits__.unwrap_or_default(), hostname: hostname__.unwrap_or_default(), block_devices: block_devices__.unwrap_or_default(), + oom_score_adj: oom_score_adj__, + pci_devices: pci_devices__.unwrap_or_default(), }) } } @@ -13571,6 +13979,9 @@ impl serde::Serialize for WorkloadStatus { if self.created_at.is_some() { len += 1; } + if self.pci_device_status.is_some() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadStatus", len)?; if self.state != 0 { let v = WorkloadState::try_from(self.state) @@ -13592,6 +14003,9 @@ impl serde::Serialize for WorkloadStatus { if let Some(v) = self.created_at.as_ref() { struct_ser.serialize_field("createdAt", v)?; } + if let Some(v) = self.pci_device_status.as_ref() { + struct_ser.serialize_field("pciDeviceStatus", v)?; + } struct_ser.end() } } @@ -13613,6 +14027,8 @@ impl<'de> serde::Deserialize<'de> for WorkloadStatus { "mountStatus", "created_at", "createdAt", + "pci_device_status", + "pciDeviceStatus", ]; #[allow(clippy::enum_variant_names)] @@ -13623,6 +14039,7 @@ impl<'de> serde::Deserialize<'de> for WorkloadStatus { BlockDeviceStatus, MountStatus, CreatedAt, + PciDeviceStatus, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -13650,6 +14067,7 @@ impl<'de> serde::Deserialize<'de> for WorkloadStatus { "blockDeviceStatus" | "block_device_status" => Ok(GeneratedField::BlockDeviceStatus), "mountStatus" | "mount_status" => Ok(GeneratedField::MountStatus), "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), + "pciDeviceStatus" | "pci_device_status" => Ok(GeneratedField::PciDeviceStatus), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -13675,6 +14093,7 @@ impl<'de> serde::Deserialize<'de> for WorkloadStatus { let mut block_device_status__ = None; let mut mount_status__ = None; let mut created_at__ = None; + let mut pci_device_status__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::State => { @@ -13713,6 +14132,12 @@ impl<'de> serde::Deserialize<'de> for WorkloadStatus { } created_at__ = map_.next_value()?; } + GeneratedField::PciDeviceStatus => { + if pci_device_status__.is_some() { + return Err(serde::de::Error::duplicate_field("pciDeviceStatus")); + } + pci_device_status__ = map_.next_value()?; + } } } Ok(WorkloadStatus { @@ -13722,6 +14147,7 @@ impl<'de> serde::Deserialize<'de> for WorkloadStatus { block_device_status: block_device_status__, mount_status: mount_status__, created_at: created_at__, + pci_device_status: pci_device_status__, }) } } @@ -20731,7 +21157,6 @@ impl serde::Serialize for ZoneState { Self::Creating => "ZONE_STATE_CREATING", Self::Created => "ZONE_STATE_CREATED", Self::Ready => "ZONE_STATE_READY", - Self::Exited => "ZONE_STATE_EXITED", Self::Destroying => "ZONE_STATE_DESTROYING", Self::Destroyed => "ZONE_STATE_DESTROYED", Self::Failed => "ZONE_STATE_FAILED", @@ -20750,7 +21175,6 @@ impl<'de> serde::Deserialize<'de> for ZoneState { "ZONE_STATE_CREATING", "ZONE_STATE_CREATED", "ZONE_STATE_READY", - "ZONE_STATE_EXITED", "ZONE_STATE_DESTROYING", "ZONE_STATE_DESTROYED", "ZONE_STATE_FAILED", @@ -20798,7 +21222,6 @@ impl<'de> serde::Deserialize<'de> for ZoneState { "ZONE_STATE_CREATING" => Ok(ZoneState::Creating), "ZONE_STATE_CREATED" => Ok(ZoneState::Created), "ZONE_STATE_READY" => Ok(ZoneState::Ready), - "ZONE_STATE_EXITED" => Ok(ZoneState::Exited), "ZONE_STATE_DESTROYING" => Ok(ZoneState::Destroying), "ZONE_STATE_DESTROYED" => Ok(ZoneState::Destroyed), "ZONE_STATE_FAILED" => Ok(ZoneState::Failed),