From 367bbaa4c8e189f008baa7b1c25eb2f1d6084660 Mon Sep 17 00:00:00 2001 From: Benjamin Leggett Date: Wed, 4 Nov 2026 14:42:26 -0500 Subject: [PATCH] chore(protos): sync the plugin with public control API changes --- .../protect/control/v1/protect.control.v1.rs | 2045 +- .../control/v1/protect.control.v1.serde.rs | 31178 +++++++++++----- .../control/v1/protect.control.v1.tonic.rs | 3151 +- .../client/edera_client/zone_watcher.rs | 4 + src/source_plugin/client/mod.rs | 9 +- src/source_plugin/mod.rs | 5 + 6 files changed, 26846 insertions(+), 9546 deletions(-) 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 aa34911..cac5eba 100644 --- a/src/proto/generated/protect/control/v1/protect.control.v1.rs +++ b/src/proto/generated/protect/control/v1/protect.control.v1.rs @@ -1,5 +1,14 @@ // @generated // This file is @generated by prost-build. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ResourceOrigin { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub workload_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub user_agent: ::prost::alloc::string::String, +} #[derive(Clone, PartialEq, ::prost::Message)] pub struct Zone { #[prost(string, tag="1")] @@ -8,15 +17,18 @@ pub struct Zone { pub spec: ::core::option::Option, #[prost(message, optional, tag="3")] pub status: ::core::option::Option, + #[prost(message, optional, tag="4")] + pub origin: ::core::option::Option, } +/// Represents a Zone. +/// - If `kernel` not specified, defaults to the daemon default kernel. +/// - If `initrd` not specified, defaults to the daemon default initrd. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ZoneSpec { #[prost(string, tag="1")] pub name: ::prost::alloc::string::String, - /// If not specified, defaults to the daemon default kernel. #[prost(message, optional, tag="2")] pub kernel: ::core::option::Option, - /// If not specified, defaults to the daemon default initrd. #[prost(message, optional, tag="3")] pub initrd: ::core::option::Option, #[prost(message, optional, tag="4")] @@ -35,8 +47,17 @@ pub struct ZoneSpec { pub scratch_disk: ::core::option::Option, #[prost(message, repeated, tag="11")] pub addons: ::prost::alloc::vec::Vec, + /// When set, this zone is a fork of the named parent zone; the reconciler + /// forks the child from the parent rather than building it from scratch. + #[prost(string, tag="12")] + pub fork_parent_zone_id: ::prost::alloc::string::String, + /// Boots the zone from a disk image via UEFI firmware instead of the + /// container path. KVM-only; mutually exclusive with `kernel`, `initrd`, + /// `addons`, `scratch_disk` (rejected by the daemon). + #[prost(message, optional, tag="14")] + pub vm_image: ::core::option::Option, } -#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ZoneResourcesSpec { #[prost(uint64, tag="1")] pub max_memory: u64, @@ -50,6 +71,8 @@ pub struct ZoneResourcesSpec { pub min_cpus: u32, #[prost(uint32, tag="4")] pub target_cpus: u32, + #[prost(message, optional, tag="8")] + pub cpus_affinities_set: ::core::option::Option, #[prost(enumeration="ZoneResourceAdjustmentPolicy", tag="5")] pub adjustment_policy: i32, } @@ -102,10 +125,18 @@ pub struct ZoneNetworkOptionsDnsSpec { #[prost(string, repeated, tag="5")] pub options: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } +/// Represents configurable zone options related to hypervisor virtualization. +/// - `numa_nodes`: Requested vNUMA node count. +/// - 0 (default) = auto: placement is driven by vCPU vs. per-node pCPU coverage, matching legacy behavior. +/// - `>0` = exact: the daemon will hard-fail if the request cannot be satisfied with exactly this many vNUMA nodes. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneVirtualizationOptionsSpec { #[prost(enumeration="ZoneVirtualizationBackend", tag="1")] pub backend: i32, + #[prost(uint32, tag="2")] + pub numa_nodes: u32, + #[prost(enumeration="NumaStrategy", tag="3")] + pub numa_strategy: i32, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct OciImageSpec { @@ -131,6 +162,8 @@ pub struct OciImageInfo { pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, #[prost(message, optional, tag="4")] pub metadata: ::core::option::Option, + #[prost(string, optional, tag="5")] + pub source_digest: ::core::option::Option<::prost::alloc::string::String>, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct ProcessSpec { @@ -163,6 +196,14 @@ pub struct MountSpec { pub host_path: ::prost::alloc::string::String, #[prost(string, tag="2")] pub target_path: ::prost::alloc::string::String, + #[prost(bool, tag="3")] + pub read_only: bool, + #[prost(enumeration="MountCacheMode", tag="4")] + pub cache: i32, + /// The host path as the orchestrator named it, when `host_path` is a resolved + /// form of it. Empty means `host_path`. + #[prost(string, tag="5")] + pub spec_host_path: ::prost::alloc::string::String, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct EnvironmentVariableSpec { @@ -226,6 +267,20 @@ pub struct ZoneStatus { pub device_status: ::core::option::Option, #[prost(message, optional, tag="10")] pub ready_at: ::core::option::Option<::pbjson_types::Timestamp>, + /// Set while the daemon holds the zone's guest paused without changing its + /// state, as an export does for as long as it copies the zone: the state + /// stays `READY`, so a runtime keeps the zone's sandbox up, but its + /// workloads are frozen until this clears. + #[prost(message, optional, tag="11")] + pub pause_status: ::core::option::Option, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZonePauseStatus { + #[prost(enumeration="ZonePauseReason", tag="1")] + pub reason: i32, + /// When the guest was paused. + #[prost(message, optional, tag="2")] + pub since: ::core::option::Option<::pbjson_types::Timestamp>, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneNetworkIp { @@ -277,6 +332,13 @@ pub struct ZoneNetworkNeighborEntry { #[prost(uint32, tag="6")] pub kind: u32, } +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZoneServiceConfig { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub service: ::prost::alloc::string::String, +} #[derive(Clone, PartialEq, ::prost::Message)] pub struct ZoneNetworkConfig { #[prost(message, repeated, tag="1")] @@ -328,8 +390,10 @@ pub struct ZoneExitStatus { pub struct ZoneErrorStatus { #[prost(string, tag="1")] pub message: ::prost::alloc::string::String, + #[prost(enumeration="ZoneErrorReason", tag="2")] + pub reason: i32, } -#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct ZoneResourceStatus { #[prost(message, optional, tag="1")] pub active_resources: ::core::option::Option, @@ -384,6 +448,13 @@ pub struct NetworkReservation { #[prost(string, tag="7")] pub gateway_mac: ::prost::alloc::string::String, } +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ServiceEntry { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub service_name: ::prost::alloc::string::String, +} #[derive(Clone, PartialEq, ::prost::Message)] pub struct WorkloadSpec { #[prost(string, tag="1")] @@ -412,6 +483,105 @@ pub struct WorkloadSpec { pub oom_score_adj: ::core::option::Option, #[prost(message, repeated, tag="13")] pub pci_devices: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="14")] + pub object_capabilities: ::core::option::Option, +} +/// Object-capability grants for a workload. Privilege is reached by connecting +/// to an endpoint, not by holding a credential. A workload may publish +/// capabilities it holds (each backed by a supervised capsudod) and receive +/// capabilities published elsewhere (each projected as a /run/ocap/ +/// socket, bridged to the provider over IDM). +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ObjectCapabilitySpec { + /// Capabilities this workload offers to others. + #[prost(message, repeated, tag="1")] + pub publishes: ::prost::alloc::vec::Vec, + /// Capabilities this workload consumes. A consume that cannot be resolved is + /// fatal: the workload will not start, because the capability is a + /// prerequisite. + #[prost(message, repeated, tag="3")] + pub consumes: ::prost::alloc::vec::Vec, +} +/// A single capability a workload consumes. +/// +/// `name` may be either a published capability's own identity or a capability +/// *type* that several publishes declare in their `implements`. When more than +/// one running provider satisfies it, the highest `priority` wins; `provider` +/// pins a specific implementation instead. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ObjectCapabilityConsumeSpec { + /// The capability requested, e.g. "dev.edera/bar". Also determines the + /// /run/ocap/ socket path projected into this workload, so the + /// consumer's path never changes when the implementation does. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Optional pin: require the implementation published under this name (e.g. + /// "dev.edera/foo"). Empty selects by priority. The pin binds late, so the + /// providing workload may restart or move zones without invalidating it. + #[prost(string, tag="2")] + pub provider: ::prost::alloc::string::String, +} +/// A single capability a workload publishes. Mirrors capsudod's attenuation: +/// a fixed command/environment and whether the client may influence them. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ObjectCapabilityPublishSpec { + /// This implementation's own identity, e.g. "dev.edera/foo". A publish always + /// satisfies a consume of its own name, in addition to everything in + /// `implements`. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Fixed program and arguments. Empty means the client supplies argv. + #[prost(string, repeated, tag="2")] + pub command: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Fixed environment entries injected into every invocation. + #[prost(message, repeated, tag="3")] + pub environment: ::prost::alloc::vec::Vec, + /// capsudod -f: ignore client-supplied argv and run `command` verbatim. + #[prost(bool, tag="4")] + pub no_client_argv: bool, + /// capsudod -E: ignore client-supplied environment. + #[prost(bool, tag="5")] + pub no_client_env: bool, + /// Run the delegated child as this uid/gid. Unset runs as the capsudod uid. + #[prost(uint32, optional, tag="6")] + pub run_as_uid: ::core::option::Option, + #[prost(uint32, optional, tag="7")] + pub run_as_gid: ::core::option::Option, + /// Working directory for the delegated child. Empty leaves it unchanged. + #[prost(string, tag="8")] + pub working_dir: ::prost::alloc::string::String, + /// Capability types this implementation satisfies, e.g. \["dev.edera/bar"\]. + /// A consume naming any of these may be bound to this publish. + #[prost(string, repeated, tag="9")] + pub implements: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Preference weight among providers of the same capability. Higher wins; + /// the default 0 makes an unweighted publish the lowest preference. Ties are + /// broken deterministically so selection is stable across daemon restarts. + #[prost(int32, tag="10")] + pub priority: i32, +} +/// Status of one published object capability, for discovery/observability. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ObjectCapabilityInfo { + /// The implementation's own identity, e.g. "dev.edera/foo". + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// The zone whose agent supervises the backing capsudod. + #[prost(string, tag="2")] + pub provider_zone_id: ::prost::alloc::string::String, + /// The publishing workload within that zone. + #[prost(string, tag="3")] + pub provider_workload_id: ::prost::alloc::string::String, + /// Whether the backing capsudod is up and accepting connections. + #[prost(bool, tag="4")] + pub ready: bool, + /// Capability types this implementation also satisfies, e.g. + /// \["dev.edera/bar"\]. A consume of any of these may resolve here. + #[prost(string, repeated, tag="5")] + pub implements: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Preference weight among providers of the same capability; higher wins. + #[prost(int32, tag="6")] + pub priority: i32, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct CgroupLimit { @@ -425,7 +595,7 @@ pub struct WorkloadScratchMount { #[prost(string, tag="1")] pub path: ::prost::alloc::string::String, } -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct WorkloadSecuritySpec { #[prost(bool, tag="1")] pub strict_user_namespace: bool, @@ -445,6 +615,64 @@ pub struct WorkloadSecuritySpec { pub read_only_rootfs: bool, #[prost(bool, tag="9")] pub no_new_privs: bool, + #[prost(enumeration="SeccompProfileType", tag="10")] + pub seccomp_profile_type: i32, + /// Path to the localhost seccomp profile, relative to the kubelet seccomp + /// root; set only when seccomp_profile_type == SECCOMP_PROFILE_TYPE_LOCALHOST. + #[prost(string, tag="11")] + pub seccomp_localhost_ref: ::prost::alloc::string::String, + #[prost(enumeration="AppArmorProfileType", tag="12")] + pub apparmor_profile_type: i32, + /// A fully-resolved seccomp filter, used instead of seccomp_profile_type/ + /// seccomp_localhost_ref by callers that have already resolved the actual + /// syscall rules themselves and have no symbolic type/path left to describe + /// it with (e.g. a containerd v2 shim: containerd's own CRI plugin resolves + /// RuntimeDefault/Localhost into the OCI spec's `linux.seccomp` before ever + /// invoking the shim, so the shim only ever sees the resolved rules, never a + /// type or a profile path). When set, this is compiled and enforced + /// verbatim, and seccomp_profile_type/seccomp_localhost_ref are ignored. + #[prost(message, optional, tag="13")] + pub resolved_seccomp_profile: ::core::option::Option, +} +/// Mirrors a resolved OCI LinuxSeccomp filter field-for-field, so a caller +/// that already has one (see WorkloadSecuritySpec.resolved_seccomp_profile) +/// can hand it over directly instead of re-deriving a symbolic type/path. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResolvedSeccompProfile { + /// e.g. "SCMP_ACT_ERRNO", "SCMP_ACT_ALLOW" (OCI's LinuxSeccompAction, as its + /// own wire string). + #[prost(string, tag="1")] + pub default_action: ::prost::alloc::string::String, + #[prost(uint32, optional, tag="2")] + pub default_errno_ret: ::core::option::Option, + /// e.g. "SCMP_ARCH_X86_64". Empty means "all/native" (OCI's default). + #[prost(string, repeated, tag="3")] + pub architectures: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, repeated, tag="4")] + pub syscalls: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResolvedSeccompSyscallRule { + #[prost(string, repeated, tag="1")] + pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag="2")] + pub action: ::prost::alloc::string::String, + #[prost(uint32, optional, tag="3")] + pub errno_ret: ::core::option::Option, + #[prost(message, repeated, tag="4")] + pub args: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ResolvedSeccompSyscallArg { + #[prost(uint32, tag="1")] + pub index: u32, + #[prost(uint64, tag="2")] + pub value: u64, + #[prost(uint64, optional, tag="3")] + pub value_two: ::core::option::Option, + /// e.g. "SCMP_CMP_EQ" (OCI's LinuxSeccompOperator). + #[prost(string, tag="4")] + pub op: ::prost::alloc::string::String, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct WorkloadStatus { @@ -462,6 +690,23 @@ pub struct WorkloadStatus { pub created_at: ::core::option::Option<::pbjson_types::Timestamp>, #[prost(message, optional, tag="7")] pub pci_device_status: ::core::option::Option, + #[prost(message, optional, tag="8")] + pub device_status: ::core::option::Option, + /// Unset until the zone starts the workload's main process. + #[prost(message, optional, tag="9")] + pub user_status: ::core::option::Option, +} +/// The identity the zone started the workload's main process with, after it +/// resolved the user and groups against the image's /etc/passwd and /etc/group. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct WorkloadUserStatus { + #[prost(uint32, tag="1")] + pub uid: u32, + #[prost(uint32, tag="2")] + pub gid: u32, + /// Every group the process is a member of, gid included, as `id -G` lists them. + #[prost(uint32, repeated, tag="3")] + pub supplemental_gids: ::prost::alloc::vec::Vec, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct WorkloadBlockDeviceInfo { @@ -474,6 +719,11 @@ pub struct WorkloadBlockDeviceInfo { #[prost(bool, tag="5")] pub loop_dev: bool, } +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct WorkloadFsDeviceInfo { + #[prost(uint64, tag="1")] + pub device_id: u64, +} #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct WorkloadPciDeviceInfo { #[prost(string, tag="1")] @@ -490,6 +740,28 @@ pub struct WorkloadPciDeviceStatus { pub devices: ::prost::alloc::vec::Vec, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct WorkloadDeviceInfo { + #[prost(oneof="workload_device_info::Info", tags="1, 2, 3")] + pub info: ::core::option::Option, +} +/// Nested message and enum types in `WorkloadDeviceInfo`. +pub mod workload_device_info { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Info { + #[prost(message, tag="1")] + Block(super::WorkloadBlockDeviceInfo), + #[prost(message, tag="2")] + Fs(super::WorkloadFsDeviceInfo), + #[prost(message, tag="3")] + Pci(super::WorkloadPciDeviceInfo), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorkloadDeviceStatus { + #[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")] pub tag: ::prost::alloc::string::String, @@ -497,6 +769,14 @@ pub struct WorkloadMountInfo { pub host_path: ::prost::alloc::string::String, #[prost(string, tag="5")] pub target_path: ::prost::alloc::string::String, + #[prost(bool, tag="6")] + pub read_only: bool, + #[prost(enumeration="MountCacheMode", tag="7")] + pub cache: i32, + /// The host path as the orchestrator named it, before any resolution. Empty + /// when it was not recorded. + #[prost(string, tag="8")] + pub spec_host_path: ::prost::alloc::string::String, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct WorkloadMountStatus { @@ -521,6 +801,8 @@ pub struct Workload { pub spec: ::core::option::Option, #[prost(message, optional, tag="3")] pub status: ::core::option::Option, + #[prost(message, optional, tag="4")] + pub origin: ::core::option::Option, } #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct HostCpuTopologyInfo { @@ -535,6 +817,64 @@ pub struct HostCpuTopologyInfo { #[prost(enumeration="HostCpuTopologyClass", tag="5")] pub class: i32, } +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct VcpuInfo { + #[prost(uint32, tag="1")] + pub vcpu: u32, + #[prost(bool, tag="2")] + pub online: bool, + #[prost(bool, tag="3")] + pub blocked: bool, + #[prost(bool, tag="4")] + pub running: bool, + #[prost(uint64, tag="5")] + pub cpu_time: u64, + #[prost(uint32, tag="6")] + pub cpu: u32, + #[prost(uint32, repeated, tag="7")] + pub hard_affinity: ::prost::alloc::vec::Vec, + #[prost(uint32, repeated, tag="8")] + pub soft_affinity: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct VcpuInfoSet { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag="2")] + pub vcpus: ::prost::alloc::vec::Vec, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct AllVcpus { +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct VcpuIdSpecifier { + #[prost(oneof="vcpu_id_specifier::Index", tags="1, 2")] + pub index: ::core::option::Option, +} +/// Nested message and enum types in `VcpuIdSpecifier`. +pub mod vcpu_id_specifier { + #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Index { + #[prost(message, tag="1")] + AllVcpus(super::AllVcpus), + #[prost(uint32, tag="2")] + Value(u32), + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct VcpuAffinitiesSpec { + #[prost(message, optional, tag="1")] + pub vcpu: ::core::option::Option, + #[prost(uint32, repeated, tag="2")] + pub hard_affinity: ::prost::alloc::vec::Vec, + #[prost(uint32, repeated, tag="3")] + pub soft_affinity: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct VcpuAffinitiesSpecSet { + #[prost(message, repeated, tag="1")] + pub entries: ::prost::alloc::vec::Vec, +} #[derive(Clone, PartialEq, ::prost::Message)] pub struct OciImageProgress { #[prost(enumeration="OciImageProgressPhase", tag="1")] @@ -636,6 +976,17 @@ pub struct ZoneScratchDiskSpecStaticBlock { #[prost(string, tag="2")] pub device: ::prost::alloc::string::String, } +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZoneVmImageSpec { + /// Resolved against the daemon's VM-image directory; absolute paths and + /// paths escaping it are rejected. + #[prost(string, tag="1")] + pub path: ::prost::alloc::string::String, + /// No autodetection: mitigates CHV format-probing CVE GHSA-jmr4-g2hv-mjj6 + /// (hardened in CHV v51.0). + #[prost(enumeration="ZoneVmImageFormat", tag="2")] + pub format: i32, +} #[derive(Clone, PartialEq, ::prost::Message)] pub struct ZoneDeviceStatus { #[prost(message, repeated, tag="1")] @@ -667,12 +1018,12 @@ pub struct ZoneMountStatus { #[prost(string, tag="3")] pub tag: ::prost::alloc::string::String, } +/// If `user` is empty, no username will be provided. +/// If `password` is empty, no password will be provided. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct OciRegistryUsernamePassword { - /// username to provide, empty means no username. #[prost(string, tag="1")] pub username: ::prost::alloc::string::String, - /// password to provide, empty means no password. #[prost(string, tag="2")] pub password: ::prost::alloc::string::String, } @@ -775,6 +1126,7 @@ pub enum ZoneVirtualizationBackend { Pv = 1, Pvh = 2, Automatic = 3, + Kvm = 4, } impl ZoneVirtualizationBackend { /// String value of the enum field names used in the ProtoBuf definition. @@ -787,6 +1139,7 @@ impl ZoneVirtualizationBackend { Self::Pv => "ZONE_VIRTUALIZATION_BACKEND_PV", Self::Pvh => "ZONE_VIRTUALIZATION_BACKEND_PVH", Self::Automatic => "ZONE_VIRTUALIZATION_BACKEND_AUTOMATIC", + Self::Kvm => "ZONE_VIRTUALIZATION_BACKEND_KVM", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -796,6 +1149,111 @@ impl ZoneVirtualizationBackend { "ZONE_VIRTUALIZATION_BACKEND_PV" => Some(Self::Pv), "ZONE_VIRTUALIZATION_BACKEND_PVH" => Some(Self::Pvh), "ZONE_VIRTUALIZATION_BACKEND_AUTOMATIC" => Some(Self::Automatic), + "ZONE_VIRTUALIZATION_BACKEND_KVM" => Some(Self::Kvm), + _ => None, + } + } +} +/// Hypervisor family a zone snapshot was exported from. A snapshot may only be +/// imported on a host running the same backend: the guest-state records inside +/// it are backend-private, so a Xen stream carries nothing a KVM host can act +/// on, and vice versa. The tag is checked before any of that state is +/// interpreted, which is what lets a second backend be added later without +/// either being able to consume the other's stream. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ZoneSnapshotBackend { + Unknown = 0, + XenPv = 1, + XenPvh = 2, + Kvm = 3, +} +impl ZoneSnapshotBackend { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unknown => "ZONE_SNAPSHOT_BACKEND_UNKNOWN", + Self::XenPv => "ZONE_SNAPSHOT_BACKEND_XEN_PV", + Self::XenPvh => "ZONE_SNAPSHOT_BACKEND_XEN_PVH", + Self::Kvm => "ZONE_SNAPSHOT_BACKEND_KVM", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ZONE_SNAPSHOT_BACKEND_UNKNOWN" => Some(Self::Unknown), + "ZONE_SNAPSHOT_BACKEND_XEN_PV" => Some(Self::XenPv), + "ZONE_SNAPSHOT_BACKEND_XEN_PVH" => Some(Self::XenPvh), + "ZONE_SNAPSHOT_BACKEND_KVM" => Some(Self::Kvm), + _ => None, + } + } +} +/// Guest instruction set a zone snapshot was exported for. Held separately from +/// the backend: one backend spans architectures whose guest state has nothing in +/// common. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ZoneSnapshotArch { + Unknown = 0, + X8664 = 1, + Aarch64 = 2, +} +impl ZoneSnapshotArch { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unknown => "ZONE_SNAPSHOT_ARCH_UNKNOWN", + Self::X8664 => "ZONE_SNAPSHOT_ARCH_X86_64", + Self::Aarch64 => "ZONE_SNAPSHOT_ARCH_AARCH64", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ZONE_SNAPSHOT_ARCH_UNKNOWN" => Some(Self::Unknown), + "ZONE_SNAPSHOT_ARCH_X86_64" => Some(Self::X8664), + "ZONE_SNAPSHOT_ARCH_AARCH64" => Some(Self::Aarch64), + _ => None, + } + } +} +/// Strategy used when expanding the selected node set beyond the seed node. +/// - UNSPECIFIED is treated as COMPACT. +/// - COMPACT: Expand to the nearest unselected NUMA node by SLIT distance from the already-selected set, tie-breaking by most free memory. +/// - SCATTER: Expand to the most distant unselected NUMA node by SLIT distance from the already-selected set, tie-breaking by most free memory. +/// Note: SLIT distance does not guarantee separation across sockets, IMCs, or LLCs; the benefit depends on the host's physical topology. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum NumaStrategy { + Unspecified = 0, + Compact = 1, + Scatter = 2, +} +impl NumaStrategy { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "NUMA_STRATEGY_UNSPECIFIED", + Self::Compact => "NUMA_STRATEGY_COMPACT", + Self::Scatter => "NUMA_STRATEGY_SCATTER", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "NUMA_STRATEGY_UNSPECIFIED" => Some(Self::Unspecified), + "NUMA_STRATEGY_COMPACT" => Some(Self::Compact), + "NUMA_STRATEGY_SCATTER" => Some(Self::Scatter), _ => None, } } @@ -844,6 +1302,67 @@ impl ProcessNamespace { } } } +/// How a host mount is cached inside the zone. CACHED enables caching for the host mount. +/// NONE disables mount caching. +/// +/// The KVM backend currently doesn't use this, because it doesn't support per-mount FS devices. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum MountCacheMode { + /// Treated as CACHED. + Unknown = 0, + Cached = 1, + None = 2, +} +impl MountCacheMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unknown => "MOUNT_CACHE_MODE_UNKNOWN", + Self::Cached => "MOUNT_CACHE_MODE_CACHED", + Self::None => "MOUNT_CACHE_MODE_NONE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "MOUNT_CACHE_MODE_UNKNOWN" => Some(Self::Unknown), + "MOUNT_CACHE_MODE_CACHED" => Some(Self::Cached), + "MOUNT_CACHE_MODE_NONE" => Some(Self::None), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ZonePauseReason { + Unknown = 0, + /// An export is copying the zone's memory, disks and captured mounts. + Export = 1, +} +impl ZonePauseReason { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unknown => "ZONE_PAUSE_REASON_UNKNOWN", + Self::Export => "ZONE_PAUSE_REASON_EXPORT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ZONE_PAUSE_REASON_UNKNOWN" => Some(Self::Unknown), + "ZONE_PAUSE_REASON_EXPORT" => Some(Self::Export), + _ => None, + } + } +} #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ZoneState { @@ -854,6 +1373,11 @@ pub enum ZoneState { Destroying = 5, Destroyed = 6, Failed = 7, + Suspending = 8, + Suspended = 9, + Resuming = 10, + Forking = 11, + Importing = 12, } impl ZoneState { /// String value of the enum field names used in the ProtoBuf definition. @@ -869,6 +1393,11 @@ impl ZoneState { Self::Destroying => "ZONE_STATE_DESTROYING", Self::Destroyed => "ZONE_STATE_DESTROYED", Self::Failed => "ZONE_STATE_FAILED", + Self::Suspending => "ZONE_STATE_SUSPENDING", + Self::Suspended => "ZONE_STATE_SUSPENDED", + Self::Resuming => "ZONE_STATE_RESUMING", + Self::Forking => "ZONE_STATE_FORKING", + Self::Importing => "ZONE_STATE_IMPORTING", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -881,6 +1410,11 @@ impl ZoneState { "ZONE_STATE_DESTROYING" => Some(Self::Destroying), "ZONE_STATE_DESTROYED" => Some(Self::Destroyed), "ZONE_STATE_FAILED" => Some(Self::Failed), + "ZONE_STATE_SUSPENDING" => Some(Self::Suspending), + "ZONE_STATE_SUSPENDED" => Some(Self::Suspended), + "ZONE_STATE_RESUMING" => Some(Self::Resuming), + "ZONE_STATE_FORKING" => Some(Self::Forking), + "ZONE_STATE_IMPORTING" => Some(Self::Importing), _ => None, } } @@ -948,6 +1482,32 @@ impl ZoneNetworkNudMode { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] +pub enum ZoneErrorReason { + Unknown = 0, + InsufficientMemory = 1, +} +impl ZoneErrorReason { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unknown => "ZONE_ERROR_REASON_UNKNOWN", + Self::InsufficientMemory => "ZONE_ERROR_REASON_INSUFFICIENT_MEMORY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ZONE_ERROR_REASON_UNKNOWN" => Some(Self::Unknown), + "ZONE_ERROR_REASON_INSUFFICIENT_MEMORY" => Some(Self::InsufficientMemory), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] pub enum MetricFormat { Unknown = 0, Bytes = 1, @@ -983,27 +1543,89 @@ impl MetricFormat { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] -pub enum WorkloadState { - Unknown = 0, - Creating = 1, - Created = 2, - Running = 3, - Completed = 4, - Destroying = 5, - Destroyed = 6, - Failed = 7, - Oomkilled = 8, -} -impl WorkloadState { +pub enum SeccompProfileType { + /// No seccomp filter (also the default when unset). + Unconfined = 0, + /// The runtime's built-in default profile. + RuntimeDefault = 1, + /// A profile loaded from a file on the node (see seccomp_localhost_ref). + Localhost = 2, +} +impl SeccompProfileType { /// String value of the enum field names used in the ProtoBuf definition. /// /// The values are not transformed in any way and thus are considered stable /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unknown => "WORKLOAD_STATE_UNKNOWN", - Self::Creating => "WORKLOAD_STATE_CREATING", - Self::Created => "WORKLOAD_STATE_CREATED", + Self::Unconfined => "SECCOMP_PROFILE_TYPE_UNCONFINED", + Self::RuntimeDefault => "SECCOMP_PROFILE_TYPE_RUNTIME_DEFAULT", + Self::Localhost => "SECCOMP_PROFILE_TYPE_LOCALHOST", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SECCOMP_PROFILE_TYPE_UNCONFINED" => Some(Self::Unconfined), + "SECCOMP_PROFILE_TYPE_RUNTIME_DEFAULT" => Some(Self::RuntimeDefault), + "SECCOMP_PROFILE_TYPE_LOCALHOST" => Some(Self::Localhost), + _ => None, + } + } +} +/// We do not support custom Localhost AppArmor policies. +/// Only RuntimeDefault, and Unconfined. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum AppArmorProfileType { + /// No AppArmor confinement (also the default when unset). + Unconfined = 0, + /// The Edera runtime's built-in default profile. + RuntimeDefault = 1, +} +impl AppArmorProfileType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unconfined => "APP_ARMOR_PROFILE_TYPE_UNCONFINED", + Self::RuntimeDefault => "APP_ARMOR_PROFILE_TYPE_RUNTIME_DEFAULT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "APP_ARMOR_PROFILE_TYPE_UNCONFINED" => Some(Self::Unconfined), + "APP_ARMOR_PROFILE_TYPE_RUNTIME_DEFAULT" => Some(Self::RuntimeDefault), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum WorkloadState { + Unknown = 0, + Creating = 1, + Created = 2, + Running = 3, + Completed = 4, + Destroying = 5, + Destroyed = 6, + Failed = 7, + Oomkilled = 8, +} +impl WorkloadState { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unknown => "WORKLOAD_STATE_UNKNOWN", + Self::Creating => "WORKLOAD_STATE_CREATING", + Self::Created => "WORKLOAD_STATE_CREATED", Self::Running => "WORKLOAD_STATE_RUNNING", Self::Completed => "WORKLOAD_STATE_COMPLETED", Self::Destroying => "WORKLOAD_STATE_DESTROYING", @@ -1057,13 +1679,13 @@ impl HostCpuTopologyClass { } } } +/// Tar and directory formats are not launchable, and are intended for internal images. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum OciImageFormat { Unknown = 0, Squashfs = 1, Erofs = 2, - /// Tar and directory formats are not launchable, and are intended for internal images. Tar = 3, Directory = 4, } @@ -1180,6 +1802,36 @@ impl OciImageProgressLayerPhase { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] +pub enum ZoneVmImageFormat { + Unspecified = 0, + Raw = 1, + /// V1: launched with in-image backing files disabled. + Qcow2 = 2, +} +impl ZoneVmImageFormat { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "ZONE_VM_IMAGE_FORMAT_UNSPECIFIED", + Self::Raw => "ZONE_VM_IMAGE_FORMAT_RAW", + Self::Qcow2 => "ZONE_VM_IMAGE_FORMAT_QCOW2", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ZONE_VM_IMAGE_FORMAT_UNSPECIFIED" => Some(Self::Unspecified), + "ZONE_VM_IMAGE_FORMAT_RAW" => Some(Self::Raw), + "ZONE_VM_IMAGE_FORMAT_QCOW2" => Some(Self::Qcow2), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] pub enum ZoneDiskStatusDiskPurpose { Unknown = 0, Addons = 1, @@ -1207,9 +1859,11 @@ impl ZoneDiskStatusDiskPurpose { } } } +/// Requests info about the current Edera daemon/host on this machine. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetHostStatusRequest { } +/// Identity, addressing, and version/build metadata for the Edera daemon/host. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetHostStatusReply { #[prost(string, tag="1")] @@ -1235,16 +1889,22 @@ pub struct GetHostStatusReply { #[prost(string, optional, tag="11")] pub protect_branch: ::core::option::Option<::prost::alloc::string::String>, } +/// Creates a new Edera zone. +/// See for details #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateZoneRequest { #[prost(message, optional, tag="1")] pub spec: ::core::option::Option, } +/// If `CreateZoneRequest` was successful, returns the UUID of the created +/// zone, which may be retained by the caller as an identifier for future zone-related RPCs. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct CreateZoneReply { #[prost(string, tag="1")] pub zone_id: ::prost::alloc::string::String, } +/// Destroys an existing Edera zone, terminating any processes running in it and releasing +/// any resources allocated to it. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DestroyZoneRequest { #[prost(string, tag="1")] @@ -1253,6 +1913,362 @@ pub struct DestroyZoneRequest { #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct DestroyZoneReply { } +/// Cooperatively suspends a running Edera zone. The guest is asked to quiesce its +/// devices and self-suspend; the zone stays resident in memory and can later be +/// resumed with `ResumeZoneRequest`. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SuspendZoneRequest { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SuspendZoneReply { +} +/// Resumes a previously suspended Edera zone, returning it to the running state. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ResumeZoneRequest { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ResumeZoneReply { +} +/// Forks a running Edera zone into a new memory-shared child zone (Xen VM-fork). +/// The parent is cooperatively suspended for the fork and then resumed; the child +/// is a copy-on-write clone that boots with its own identity (UUID, network). +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ForkZoneRequest { + /// The zone to fork from. + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + /// Optional name for the forked child zone. + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, +} +/// Returns the UUID of the newly forked child zone. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ForkZoneReply { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, +} +/// Exports a zone's complete state -- vcpus, guest memory, hypervisor +/// configuration, device topology, the contents of its writable disks, and the +/// zone's own control-plane record and workloads -- as a snapshot: a stream of +/// opaque bytes the caller stores and later hands back to `ImportZone`. +/// +/// The zone is cooperatively suspended for the export and resumed afterwards +/// unless `leave_suspended` is set, so a snapshot is a consistent point rather +/// than a smear of a running guest. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExportZoneRequest { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + /// Leave the zone suspended once the export completes instead of resuming it. + /// Use this when the snapshot is about to become the live copy elsewhere. + #[prost(bool, tag="2")] + pub leave_suspended: bool, + /// Compress record payloads. Guest memory compresses well; the cost is host + /// CPU during the export. + #[prost(bool, tag="3")] + pub compress: bool, + /// Mounts whose host directory's contents the snapshot carries, so a restore + /// can fill the directory it binds them to. Mounts that name the same host + /// directory share one copy. Needs the daemon's `restore-mount-data-v0` + /// feature. + #[prost(message, repeated, tag="5")] + pub capture_mounts: ::prost::alloc::vec::Vec, +} +/// One mount of one of the zone's workloads. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct CapturedMountRef { + #[prost(string, tag="1")] + pub workload_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub target_path: ::prost::alloc::string::String, +} +/// Streamed reply for `ExportZone`. The first message carries `start`, +/// describing the snapshot about to be streamed; then `chunk`s carrying its +/// bytes in order; then a final `complete`. The concatenation of every `chunk` +/// is the snapshot, and nothing else in the stream belongs in the stored bytes. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ExportZoneReply { + #[prost(oneof="export_zone_reply::Reply", tags="1, 2, 3")] + pub reply: ::core::option::Option, +} +/// Nested message and enum types in `ExportZoneReply`. +pub mod export_zone_reply { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Reply { + #[prost(message, tag="1")] + Start(super::ExportZoneStart), + #[prost(bytes, tag="2")] + Chunk(::prost::alloc::vec::Vec), + #[prost(message, tag="3")] + Complete(super::ExportZoneComplete), + } +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ExportZoneStart { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(enumeration="ZoneSnapshotBackend", tag="2")] + pub backend: i32, + #[prost(enumeration="ZoneSnapshotArch", tag="3")] + pub arch: i32, + #[prost(uint32, tag="4")] + pub format_version: u32, +} +/// Closes the reply stream once the export is complete, so a caller can check +/// that the snapshot it wrote is as long as what the daemon sent. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ExportZoneComplete { + #[prost(uint64, tag="1")] + pub total_bytes: u64, + /// Bytes of archive carried for the mounts named in `capture_mounts`. A + /// restore needs this much free space on the target host while it runs. + #[prost(uint64, tag="2")] + pub captured_mount_bytes: u64, +} +/// Recreates a zone from a snapshot produced by `ExportZone`. The first message +/// must carry `start`; every message after it carries a `chunk` of the +/// snapshot, in the order it was received. +/// +/// The daemon checks the snapshot against this host before acting on any of the +/// guest state it carries: the backend and architecture must match, and the +/// guest's CPU, clock, zone agent and hypervisor state must be ones this host +/// can continue. Read-only images the snapshot references by path must exist +/// here unchanged in size. A refusal names every incompatibility found. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ImportZoneRequest { + #[prost(oneof="import_zone_request::Request", tags="1, 2")] + pub request: ::core::option::Option, +} +/// Nested message and enum types in `ImportZoneRequest`. +pub mod import_zone_request { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Request { + #[prost(message, tag="1")] + Start(super::ImportZoneStart), + #[prost(bytes, tag="2")] + Chunk(::prost::alloc::vec::Vec), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ImportZoneStart { + /// Overrides the zone name recorded in the snapshot. Empty keeps it. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Import under this zone id instead of a freshly allocated one. Empty + /// allocates a new id, which is what lets one snapshot seed many zones. + #[prost(string, tag="2")] + pub zone_id: ::prost::alloc::string::String, + /// Hold the imported zone, paused and with its host mounts unbound, for a + /// runtime that claims it with the same `claim`. + #[prost(message, optional, tag="4")] + pub restore: ::core::option::Option, +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ImportZoneReply { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, +} +/// Makes one or more copies of a zone, by fork or by export and import. A mode +/// the zone or the backend does not support fails the call with the reason; the +/// daemon never falls back from a mode the caller named. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ReplicateZoneRequest { + /// How to make the replicas. Automatic lets the daemon choose. + #[prost(enumeration="ZoneReplicateMode", tag="1")] + pub mode: i32, + /// The zone to replicate. Not read when `export_path` is set, so it may be + /// empty then, or name a zone that no longer exists. + #[prost(string, tag="2")] + pub zone_id: ::prost::alloc::string::String, + /// A snapshot file on the host, as returned by an earlier `ReplicateZone`. + /// The export is skipped and each replica is imported from this file, which + /// the daemon never deletes. Only valid for export/import, and so for + /// `ZONE_REPLICATE_MODE_AUTOMATIC` it selects export/import. + #[prost(string, tag="3")] + pub export_path: ::prost::alloc::string::String, + /// Number of replicas. Zero means one. When `names` is set, it must have this + /// many entries or this must be zero. + #[prost(uint32, tag="4")] + pub replicas: u32, + /// Names for the replicas, in order. Empty entries, or no entries, keep the + /// zone's name. + #[prost(string, repeated, tag="5")] + pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Delete the snapshot file once the replicas are imported, when this call + /// made it. A file named by `export_path` is the caller's and is never + /// deleted. Fork ignores it. + #[prost(bool, tag="6")] + pub delete_export: bool, +} +/// The result of a `ReplicateZone` that got as far as making replicas. A replica +/// that failed is reported in `replicas` with its `error`, and the replicas +/// after it are not attempted, so a caller reads `replicas` rather than the +/// call's status to learn what exists. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ReplicateZoneReply { + /// The mode used. + #[prost(enumeration="ZoneReplicateMode", tag="1")] + pub mode: i32, + /// The snapshot file of an export/import, which the caller owns from here on + /// and may pass as `export_path` to replicate again. Empty for fork, and when + /// the daemon deleted the file. + #[prost(string, tag="2")] + pub export_path: ::prost::alloc::string::String, + /// One entry per requested replica, in the order of the request's `names`. + #[prost(message, repeated, tag="3")] + pub replicas: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ReplicatedZone { + /// Empty when the replica was not created. + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + /// The name requested for the replica. Empty when it keeps the zone's name. + #[prost(string, tag="2")] + pub name: ::prost::alloc::string::String, + /// Why the replica was not created. Empty when it was. + #[prost(string, tag="3")] + pub error: ::prost::alloc::string::String, +} +/// What an imported zone is held for. The zone waits, paused, until a runtime +/// presents the same `claim`, so a runtime can only claim a zone that was +/// imported for it. The daemon compares the string and nothing more. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RestoreClaim { + #[prost(string, tag="1")] + pub claim: ::prost::alloc::string::String, + /// Kept with the zone and returned when it is claimed. The daemon does not + /// read them. + #[prost(message, repeated, tag="2")] + pub annotations: ::prost::alloc::vec::Vec, +} +/// Claims the zone imported for `claim`. Waits, up to the daemon's claim +/// timeout, for the import to exist. A zone can be claimed once. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ClaimRestoredZoneRequest { + #[prost(string, tag="1")] + pub claim: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClaimRestoredZoneReply { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag="2")] + pub workloads: ::prost::alloc::vec::Vec, + /// The annotations the import was given. + #[prost(message, repeated, tag="3")] + pub annotations: ::prost::alloc::vec::Vec, +} +/// A workload the restored zone was running, as the snapshot recorded it. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RestoredWorkload { + #[prost(string, tag="1")] + pub workload_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub image: ::prost::alloc::string::String, + #[prost(message, repeated, tag="3")] + pub annotations: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="4")] + pub mounts: ::prost::alloc::vec::Vec, +} +/// A host mount of a restored workload. `recorded_host_path` names a path on the +/// host that took the snapshot and is only a hint: the daemon never binds it. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct RestoredMount { + #[prost(string, tag="1")] + pub target_path: ::prost::alloc::string::String, + #[prost(bool, tag="2")] + pub read_only: bool, + #[prost(string, tag="3")] + pub recorded_host_path: ::prost::alloc::string::String, + /// The snapshot carries the contents of the host directory the mount was + /// bound to, so a binding can ask for its new directory to be filled. + #[prost(bool, tag="4")] + pub captured: bool, + /// The host path as the orchestrator named it when the mount was created, + /// before any resolution. Empty for snapshots taken before it was recorded, + /// in which case only `recorded_host_path` is known. + #[prost(string, tag="5")] + pub recorded_spec_host_path: ::prost::alloc::string::String, +} +/// Where one mount of a restored workload is bound before its zone resumes. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct RestoredBinding { + #[prost(string, tag="1")] + pub workload_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub target_path: ::prost::alloc::string::String, + /// The host path to bind. The daemon resolves it and refuses one outside its + /// configured restore bind roots. Empty binds `placeholder` instead. + #[prost(string, tag="3")] + pub host_path: ::prost::alloc::string::String, + #[prost(enumeration="RestoredPlaceholder", tag="4")] + pub placeholder: i32, + /// Fill `host_path`, which must be set and name an empty directory, from the + /// contents the snapshot carries for this mount before binding it. A binding + /// that sets `fill` without `host_path` (that is, one bound to a + /// `placeholder`) is refused. Every binding of mounts that share those + /// contents must name the same directory. + #[prost(bool, tag="5")] + pub fill: bool, + /// The host path as the orchestrator named it, when `host_path` is a resolved + /// form of it. The daemon records it on the workload's mount status, so a + /// later snapshot of this zone can be compared against the orchestrator's + /// spec without touching the filesystem. Empty means `host_path`. + #[prost(string, tag="6")] + pub spec_host_path: ::prost::alloc::string::String, +} +/// Binds every mount of a claimed zone, then resumes it. Each mount of each +/// running workload not in `dropped_workload_ids` needs exactly one binding. `annotations` are set on the +/// zone's spec, replacing any with the same key. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StartRestoredZoneRequest { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag="2")] + pub bindings: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="3")] + pub annotations: ::prost::alloc::vec::Vec, + /// Workloads the snapshot carries that the orchestrator does not restore, such + /// as a Kubernetes pod's ephemeral containers. They need no bindings, and the + /// daemon destroys them as soon as the zone resumes. + #[prost(string, repeated, tag="4")] + pub dropped_workload_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct StartRestoredZoneReply { +} +/// Binds a restored workload to the container a runtime created for it. +/// `mounts` are the container's own mounts: each of the workload's recorded +/// mounts must have exactly one with the same target path and read-only flag, +/// and no other mount may be left over. A mount whose resolved host path differs +/// from the one it is bound to is rebound. `annotations` are set on the +/// workload, replacing any with the same key. Repeating the call for the same +/// workload replaces the earlier one. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AdoptWorkloadRequest { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub workload_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub container_id: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub sandbox_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag="5")] + pub mounts: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="6")] + pub annotations: ::prost::alloc::vec::Vec, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct AdoptWorkloadReply { +} +/// Resolves zone "friendly name" to a singular zone UUID, if possible. Matching is exact. +/// See also `ResolveZoneIdsRequest` (plural). #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ResolveZoneIdRequest { #[prost(string, tag="1")] @@ -1263,6 +2279,8 @@ pub struct ResolveZoneIdReply { #[prost(string, tag="1")] pub zone_id: ::prost::alloc::string::String, } +/// In cases where multiple zones share the same "friendly name", return a list of all +/// distinct zone_ids that match that "friendly name". Matching is exact. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ResolveZoneIdsRequest { #[prost(string, tag="1")] @@ -1273,6 +2291,7 @@ pub struct ResolveZoneIdsReply { #[prost(string, repeated, tag="1")] pub zone_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } +/// Request detailed zone information for a given zone UUID. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetZoneRequest { #[prost(string, tag="1")] @@ -1283,23 +2302,248 @@ pub struct GetZoneReply { #[prost(message, optional, tag="1")] pub zone: ::core::option::Option, } +/// List all zones being currently managed by Edera. This will include zones that are +/// no longer running or in a failed state, as well as running zones. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ListZonesRequest { } +/// A streamed batch of zones. The full zone list is the concatenation of all streamed message replies. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListZonesReply { #[prost(message, repeated, tag="1")] pub zones: ::prost::alloc::vec::Vec, } +/// Get info for all vCPUs of specified zones. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetZonesVcpuInfosRequest { + #[prost(string, repeated, tag="1")] + pub zone_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// A streamed batch of per-zone vCPU info sets. The full result is the concatenation of all +/// streamed message replies. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetZonesVcpuInfosReply { + #[prost(message, repeated, tag="1")] + pub vcpu_info_sets: ::prost::alloc::vec::Vec, +} +/// Sets the hard and soft CPU affinities for zone vCPUs. +/// `vCPU` can be either the vCPU index or the string "all". +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SetZoneVcpuAffinityRequest { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub vcpu: ::prost::alloc::string::String, + #[prost(uint32, repeated, tag="3")] + pub hard_affinity: ::prost::alloc::vec::Vec, + #[prost(uint32, repeated, tag="4")] + pub soft_affinity: ::prost::alloc::vec::Vec, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SetZoneVcpuAffinityReply { +} +/// Send this control message to Edera to initiate a stream of kernel events +/// from the specified zone_id. +/// Sending `ZoneKernelEventStreamUpdate` initiates the stream, if one is not active, or updates +/// the config of its source, if one is. +/// Sending `ZoneKernelEventStreamStop` terminates the stream, if one is active. +/// +/// See `MonitorZonekernelEventReply` for the kinds of stream responses to expect. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct MonitorZoneKernelEventRequest { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(oneof="monitor_zone_kernel_event_request::Request", tags="3, 4")] + pub request: ::core::option::Option, +} +/// Nested message and enum types in `MonitorZoneKernelEventRequest`. +pub mod monitor_zone_kernel_event_request { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Request { + #[prost(message, tag="3")] + Update(super::ZoneKernelEventStreamUpdate), + #[prost(message, tag="4")] + Stop(super::ZoneKernelEventStreamStop), + } +} +/// The first `MonitorZoneKernelEventReply` is always `started`, which names the source the zone +/// streams and the config it applied. A client skips replies of a kind it does not know. +/// +/// The syscall source then sends a `ZoneKernelThreadSnapshotEvent`. This snapshot contains the +/// current thread and process state of the zone, and is used by the Falco plugin to maintain a +/// per-zone clientside cache of threads and processes to correlate later raw syscall events against. +/// After it come `ZoneKernelSyscallEvent`s. +/// +/// Note that `zone_id` is intentionally duplicated within each +/// reply type, and not simply defined once in the toplevel +/// message. This makes bincoding the internal reply types as bytes easier. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MonitorZoneKernelEventReply { + #[prost(oneof="monitor_zone_kernel_event_reply::Reply", tags="2, 3, 4, 5")] + pub reply: ::core::option::Option, +} +/// Nested message and enum types in `MonitorZoneKernelEventReply`. +pub mod monitor_zone_kernel_event_reply { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Reply { + #[prost(message, tag="2")] + Syscall(super::ZoneKernelSyscallEvent), + #[prost(message, tag="3")] + Threadsnap(super::ZoneKernelThreadSnapshotEvent), + #[prost(message, tag="4")] + Started(super::ZoneKernelEventStreamStarted), + #[prost(message, tag="5")] + NetworkEvents(super::ZoneKernelNetworkEvents), + } +} +/// Initiates a stream, if one is not active, or updates the config of the current +/// stream's source, if one is. A request names its source, and the daemon fails a +/// stream whose source it does not know. A stream keeps the source it started with. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelEventStreamUpdate { - #[prost(uint32, repeated, tag="2")] + #[prost(oneof="zone_kernel_event_stream_update::Source", tags="3, 4")] + pub source: ::core::option::Option, +} +/// Nested message and enum types in `ZoneKernelEventStreamUpdate`. +pub mod zone_kernel_event_stream_update { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Source { + #[prost(message, tag="3")] + Syscalls(super::ZoneKernelSyscallSource), + #[prost(message, tag="4")] + NetworkEvents(super::ZoneKernelNetworkSource), + } +} +/// The libscap syscall source, which the Falco plugin uses. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZoneKernelSyscallSource { + /// The syscalls to raise events for, by Linux syscall ID number. Empty selects the + /// zone's default set. + /// See + #[prost(uint32, repeated, tag="1")] pub enabled_syscalls: ::prost::alloc::vec::Vec, } +/// The source a stream runs, with the config the zone applied, which leaves out +/// any IDs it does not know. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZoneKernelEventStreamStarted { + #[prost(oneof="zone_kernel_event_stream_started::Source", tags="1, 2")] + pub source: ::core::option::Option, +} +/// Nested message and enum types in `ZoneKernelEventStreamStarted`. +pub mod zone_kernel_event_stream_started { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Source { + #[prost(message, tag="1")] + Syscalls(super::ZoneKernelSyscallSource), + #[prost(message, tag="2")] + NetworkEvents(super::ZoneKernelNetworkSource), + } +} +/// The zone's TCP connections and UDP flows. It sends `network_events` batches +/// after `started`. The zone fails a stream that names only protocols or a +/// direction it does not know. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZoneKernelNetworkSource { + /// Report only these protocols. Empty reports every protocol. + #[prost(enumeration="ZoneKernelNetworkProtocol", repeated, tag="1")] + pub protocols: ::prost::alloc::vec::Vec, + /// Report only this direction. Unspecified reports both, and events whose + /// direction is not known. + #[prost(enumeration="ZoneKernelNetworkDirection", tag="2")] + pub direction: i32, + /// Report only this process, by its PID in the zone's root PID namespace. + #[prost(uint32, optional, tag="3")] + pub pid: ::core::option::Option, +} +/// The network events the zone saw since its previous batch. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ZoneKernelNetworkEvents { + #[prost(string, tag="1")] + pub zone_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag="2")] + pub events: ::prost::alloc::vec::Vec, + /// Events the zone lost since the previous batch, because its buffer was full. + #[prost(uint64, tag="3")] + pub dropped: u64, + /// Batches the zone skipped for this stream since the previous batch, because + /// the stream fell behind. Their events are lost, and are not in `dropped`. + #[prost(uint64, tag="4")] + pub skipped_batches: u64, +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZoneKernelNetworkEvent { + /// Nanoseconds since the epoch, on the zone clock. + #[prost(uint64, tag="1")] + pub timestamp: u64, + /// The process that made the connection or sent or received the datagram, in + /// the zone's root PID namespace. + #[prost(uint32, tag="2")] + pub pid: u32, + #[prost(string, tag="3")] + pub comm: ::prost::alloc::string::String, + #[prost(oneof="zone_kernel_network_event::Event", tags="16, 17")] + pub event: ::core::option::Option, +} +/// Nested message and enum types in `ZoneKernelNetworkEvent`. +pub mod zone_kernel_network_event { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Event { + #[prost(message, tag="16")] + TcpConnection(super::ZoneKernelTcpConnection), + #[prost(message, tag="17")] + UdpFlow(super::ZoneKernelUdpFlow), + } +} +/// A TCP connection: an outbound connect that finished, or an inbound +/// connection that a process accepted. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZoneKernelTcpConnection { + /// 4 bytes for IPv4, 16 for IPv6. + #[prost(bytes="vec", tag="1")] + pub local_address: ::prost::alloc::vec::Vec, + #[prost(uint32, tag="2")] + pub local_port: u32, + #[prost(bytes="vec", tag="3")] + pub remote_address: ::prost::alloc::vec::Vec, + #[prost(uint32, tag="4")] + pub remote_port: u32, + /// Outbound: nanoseconds from the SYN to the result. Inbound: nanoseconds + /// the connection waited, after its handshake, for the process to accept it. + #[prost(uint64, tag="5")] + pub latency: u64, + /// False for an outbound connect that failed: refused, unreachable, or timed + /// out. Always true for inbound. + #[prost(bool, tag="6")] + pub established: bool, + #[prost(enumeration="ZoneKernelNetworkDirection", tag="7")] + pub direction: i32, +} +/// The first datagram of a UDP flow: a socket and a remote address and port. +/// Later datagrams of the flow, either way, are not reported, unless the zone +/// forgets the flow under load. The event's process is the one that sent or +/// received that first datagram. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZoneKernelUdpFlow { + /// 4 bytes for IPv4, 16 for IPv6. All zeros when the socket is not bound to + /// a local address. + #[prost(bytes="vec", tag="1")] + pub local_address: ::prost::alloc::vec::Vec, + #[prost(uint32, tag="2")] + pub local_port: u32, + #[prost(bytes="vec", tag="3")] + pub remote_address: ::prost::alloc::vec::Vec, + #[prost(uint32, tag="4")] + pub remote_port: u32, + #[prost(enumeration="ZoneKernelNetworkDirection", tag="5")] + pub direction: i32, +} +/// Stops the current kernel event stream subscription. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelEventStreamStop { } /// roughly maps to libscap's `scap_threadinfo` type. +/// See #[derive(Clone, PartialEq, ::prost::Message)] pub struct ZoneKernelThreadInfo { #[prost(uint64, optional, tag="1")] @@ -1394,6 +2638,7 @@ pub struct ZoneKernelThreadInfo { #[prost(bool, tag="45")] pub reaper: bool, } +/// roughly maps to libscap's `scap_fdinfo` type. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelFdInfo { /// unset fd id == invalid fd info @@ -1412,6 +2657,8 @@ pub struct ZoneKernelFdInfo { #[prost(uint32, tag="6")] pub state_flags: u32, } +/// Type-specific info for a file descriptor. The variant set here corresponds to +/// the `ZoneKernelFdType` of the enclosing `ZoneKernelFdInfo`. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelFdInfoData { #[prost(oneof="zone_kernel_fd_info_data::InfoType", tags="1, 2, 3, 4, 5, 6, 7, 8")] @@ -1439,6 +2686,7 @@ pub mod zone_kernel_fd_info_data { Pidfd(super::ZoneKernelPidFd), } } +/// Endpoint info for a connected IPv4 socket. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelIpv4SocketInfo { /// IPv4 address as string @@ -1454,6 +2702,7 @@ pub struct ZoneKernelIpv4SocketInfo { #[prost(enumeration="ZoneKernelIpProtocol", tag="5")] pub protocol: i32, } +/// Endpoint info for a connected IPv6 socket. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelIpv6SocketInfo { /// IPv6 address as string @@ -1469,6 +2718,7 @@ pub struct ZoneKernelIpv6SocketInfo { #[prost(enumeration="ZoneKernelIpProtocol", tag="5")] pub protocol: i32, } +/// Endpoint info for a listening IPv4 server socket. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelIpv4ServerSocketInfo { /// IPv4 address as string @@ -1479,6 +2729,7 @@ pub struct ZoneKernelIpv4ServerSocketInfo { #[prost(enumeration="ZoneKernelIpProtocol", tag="3")] pub protocol: i32, } +/// Endpoint info for a listening IPv6 server socket. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelIpv6ServerSocketInfo { /// IPv6 address as string @@ -1489,6 +2740,8 @@ pub struct ZoneKernelIpv6ServerSocketInfo { #[prost(enumeration="ZoneKernelIpProtocol", tag="3")] pub protocol: i32, } +/// Info for a unix domain socket. `source` and `destination` are opaque kernel socket +/// identifiers, per libscap. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelUnixSocketInfo { #[prost(uint64, tag="1")] @@ -1498,6 +2751,7 @@ pub struct ZoneKernelUnixSocketInfo { #[prost(string, tag="3")] pub name: ::prost::alloc::string::String, } +/// Info for a regular open file. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelRegularFileInfo { #[prost(uint32, tag="1")] @@ -1509,11 +2763,13 @@ pub struct ZoneKernelRegularFileInfo { #[prost(uint32, tag="4")] pub device: u32, } +/// Info for a pidfd: the PID of the process the fd refers to. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelPidFd { #[prost(uint64, tag="1")] pub pid: u64, } +/// Represents a captured syscall event from the zone kernel. /// Roughly maps to the Falco libscap format for generic events: /// #[derive(Clone, PartialEq, ::prost::Message)] @@ -1543,6 +2799,11 @@ pub struct ZoneKernelSyscallEvent { #[prost(message, repeated, tag="7")] pub event_params: ::prost::alloc::vec::Vec, } +/// Sent as an ACK response to a `MonitorZoneKernelEventRequest` of type `ZoneKernelEventStreamUpdate`. +/// Contains a complete snapshot of zone threads, which is used by the Falco plugin to maintain a per-zone clientside +/// cache of threads and processes to correlate the subsequent raw syscall event stream against. +/// This is useful because e.g. if you get a `fork` syscall event from an existing thread, you can correlate the +/// parent TID against the data in this snapshot to hydrate info about the parent thread, if needed or desired. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ZoneKernelThreadSnapshotEvent { #[prost(string, tag="2")] @@ -1553,42 +2814,6 @@ pub struct ZoneKernelThreadSnapshotEvent { #[prost(uint64, tag="3")] pub zone_boot_epoch: u64, } -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct MonitorZoneKernelEventRequest { - #[prost(string, tag="1")] - pub zone_id: ::prost::alloc::string::String, - #[prost(oneof="monitor_zone_kernel_event_request::Request", tags="3, 4")] - pub request: ::core::option::Option, -} -/// Nested message and enum types in `MonitorZoneKernelEventRequest`. -pub mod monitor_zone_kernel_event_request { - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] - pub enum Request { - #[prost(message, tag="3")] - Update(super::ZoneKernelEventStreamUpdate), - #[prost(message, tag="4")] - Stop(super::ZoneKernelEventStreamStop), - } -} -/// Note that `zone_id` is duplicated within each -/// reply type, and not simply defined once in the toplevel -/// message. This is intentional, as it makes bincoding the -/// internal reply types as bytes easier. -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MonitorZoneKernelEventReply { - #[prost(oneof="monitor_zone_kernel_event_reply::Reply", tags="2, 3")] - pub reply: ::core::option::Option, -} -/// Nested message and enum types in `MonitorZoneKernelEventReply`. -pub mod monitor_zone_kernel_event_reply { - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Reply { - #[prost(message, tag="2")] - Syscall(super::ZoneKernelSyscallEvent), - #[prost(message, tag="3")] - Threadsnap(super::ZoneKernelThreadSnapshotEvent), - } -} /// in libscap, events are packed on the wire accordingly: /// - a header /// - an arbitrary sequence of 2-or-4-byte numbers for each param, indicating param lengths @@ -1597,6 +2822,7 @@ pub mod monitor_zone_kernel_event_reply { /// This represents the non-header parts of the event. /// The number of paramters, as well as whether the param lengths are represented as 2 or 4 byte numbers, /// is defined by the header in libscap, but for convenience those are colocated in this message here. +/// See #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneKernelEventParam { #[prost(string, tag="1")] @@ -1610,6 +2836,16 @@ pub struct ZoneKernelEventParam { #[prost(string, tag="5")] pub param_type_pretty: ::prost::alloc::string::String, } +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DiscoverServicesRequest { +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DiscoverServicesReply { + #[prost(message, repeated, tag="1")] + pub service_entry: ::prost::alloc::vec::Vec, +} +/// Client stream message for `ExecuteZoneCommand`. The first message sent must be an +/// `ExecuteZoneCommandStart`; subsequent messages carry stdin data or terminal resizes. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExecuteZoneCommandRequest { #[prost(oneof="execute_zone_command_request::Request", tags="1, 2, 3")] @@ -1627,6 +2863,8 @@ pub mod execute_zone_command_request { TerminalResize(super::ExecuteZoneCommandTerminalResize), } } +/// Starts a process in the specified zone. If `workload_id` is set, the process is spawned +/// inside that workload's container, otherwise it runs in the zone context itself. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExecuteZoneCommandStart { #[prost(string, tag="1")] @@ -1636,6 +2874,7 @@ pub struct ExecuteZoneCommandStart { #[prost(message, optional, tag="3")] pub process: ::core::option::Option, } +/// A chunk of stdin for the running process. Set `closed` to signal EOF on stdin. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ExecuteZoneCommandStdin { #[prost(bytes="vec", tag="1")] @@ -1643,11 +2882,13 @@ pub struct ExecuteZoneCommandStdin { #[prost(bool, tag="2")] pub closed: bool, } +/// Resizes the terminal of the running process, if it was started with a tty. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ExecuteZoneCommandTerminalResize { #[prost(message, optional, tag="1")] pub size: ::core::option::Option, } +/// A chunk of stdout/stderr output from the running process. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ExecuteZoneCommandOutput { #[prost(bytes="vec", tag="1")] @@ -1655,11 +2896,14 @@ pub struct ExecuteZoneCommandOutput { #[prost(bytes="vec", tag="2")] pub stderr: ::prost::alloc::vec::Vec, } +/// Indicates the process exited with `exit_code`. This is the final reply on the stream. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ExecuteZoneCommandExited { #[prost(int32, tag="1")] pub exit_code: i32, } +/// Server stream message for `ExecuteZoneCommand`: output chunks as they arrive, +/// terminated by an `ExecuteZoneCommandExited` when the process exits. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ExecuteZoneCommandReply { #[prost(oneof="execute_zone_command_reply::Reply", tags="1, 2")] @@ -1675,6 +2919,9 @@ pub mod execute_zone_command_reply { Exited(super::ExecuteZoneCommandExited), } } +/// Client stream message for `AttachZoneConsole`. `data` is written to the zone console. +/// Set `replay_history` on the first message to receive buffered console history before +/// live output. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneConsoleRequest { #[prost(string, tag="1")] @@ -1684,11 +2931,15 @@ pub struct ZoneConsoleRequest { #[prost(bool, tag="3")] pub replay_history: bool, } +/// A chunk of zone console output. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ZoneConsoleReply { #[prost(bytes="vec", tag="1")] pub data: ::prost::alloc::vec::Vec, } +/// Client stream message for `AttachWorkloadConsole`. Attaches to the stdio of the +/// workload's main process: `stdin` bytes are forwarded to the process, `stdin_closed` +/// signals stdin EOF, and `terminal_resize` resizes the process terminal, if it has one. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct WorkloadConsoleRequest { #[prost(string, tag="1")] @@ -1700,6 +2951,7 @@ pub struct WorkloadConsoleRequest { #[prost(message, optional, tag="4")] pub terminal_resize: ::core::option::Option, } +/// A chunk of stdout/stderr output from the workload's main process. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct WorkloadConsoleReply { #[prost(bytes="vec", tag="1")] @@ -1707,12 +2959,14 @@ pub struct WorkloadConsoleReply { #[prost(bytes="vec", tag="2")] pub stderr: ::prost::alloc::vec::Vec, } +/// Subscribes to a stream of state changes for all zones and workloads on this host. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct WatchEventsRequest { } +/// A single zone or workload change event. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WatchEventsReply { - #[prost(oneof="watch_events_reply::Event", tags="1, 2")] + #[prost(oneof="watch_events_reply::Event", tags="1, 2, 3, 4")] pub event: ::core::option::Option, } /// Nested message and enum types in `WatchEventsReply`. @@ -1723,31 +2977,178 @@ pub mod watch_events_reply { ZoneChanged(super::ZoneChangedEvent), #[prost(message, tag="2")] WorkloadChanged(super::WorkloadChangedEvent), + #[prost(message, tag="3")] + AdvertiseService(super::AdvertiseServiceEvent), + #[prost(message, tag="4")] + UnadvertiseService(super::UnadvertiseServiceEvent), } } +/// Carries the full current state of a zone whose state has changed. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ZoneChangedEvent { #[prost(message, optional, tag="1")] pub zone: ::core::option::Option, } +/// Carries the full current state of a workload whose state has changed. #[derive(Clone, PartialEq, ::prost::Message)] pub struct WorkloadChangedEvent { #[prost(message, optional, tag="1")] pub workload: ::core::option::Option, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct AdvertiseServiceEvent { + #[prost(message, optional, tag="1")] + pub service_entry: ::core::option::Option, +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UnadvertiseServiceEvent { + #[prost(string, tag="1")] + pub uuid: ::prost::alloc::string::String, +} +/// Reads the most recently collected metrics (memory, CPU, etc.) for the given zone. +/// Metrics are served from a daemon-managed cache. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadZoneMetricsRequest { #[prost(string, tag="1")] pub zone_id: ::prost::alloc::string::String, } +/// The root of the zone metrics tree. `root` is unset if no metrics are available for the +/// zone (zone metrics disabled, metrics stale, etc). #[derive(Clone, PartialEq, ::prost::Message)] pub struct ReadZoneMetricsReply { #[prost(message, optional, tag="1")] pub root: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub processes: ::core::option::Option, +} +/// A zone's processes. The field numbers match the zone's own process table +/// messages, so the daemon passes the records through as the zone sent them. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ZoneProcessTable { + /// The zone clock at the last update, in seconds. A process has run for + /// `uptime - (start_time - boot_time)` seconds. + #[prost(uint64, tag="2")] + pub boot_time: u64, + #[prost(uint64, tag="3")] + pub uptime: u64, + /// In pid order. + #[prost(message, repeated, tag="4")] + pub processes: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ZoneProcess { + #[prost(uint32, tag="1")] + pub pid: u32, + #[prost(uint32, optional, tag="2")] + pub parent: ::core::option::Option, + #[prost(string, tag="3")] + pub name: ::prost::alloc::string::String, + #[prost(string, optional, tag="4")] + pub executable: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, optional, tag="5")] + pub cwd: ::core::option::Option<::prost::alloc::string::String>, + #[prost(string, repeated, tag="6")] + pub cmdline: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Seconds since the epoch, on the zone clock. + #[prost(uint64, tag="7")] + pub start_time: u64, + #[prost(uint32, tag="8")] + pub uid: u32, + #[prost(uint32, tag="9")] + pub gid: u32, + #[prost(uint32, tag="10")] + pub euid: u32, + #[prost(uint32, tag="11")] + pub egid: u32, + /// A kernel thread, which has no memory, executable or argv. + #[prost(bool, tag="12")] + pub kernel: bool, + #[prost(message, optional, tag="13")] + pub sample: ::core::option::Option, + /// The cgroup v2 path, as in /proc//cgroup. + #[prost(string, tag="14")] + pub cgroup: ::prost::alloc::string::String, + #[prost(uint32, tag="15")] + pub saved_uid: u32, + #[prost(uint32, tag="16")] + pub filesystem_uid: u32, + #[prost(uint32, tag="17")] + pub saved_gid: u32, + #[prost(uint32, tag="18")] + pub filesystem_gid: u32, + #[prost(uint32, repeated, tag="19")] + pub groups: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="20")] + pub capabilities: ::core::option::Option, +} +/// The values of a process that change with no kernel event, read at each +/// scrape. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ZoneProcessSample { + #[prost(uint64, tag="1")] + pub resident: u64, + #[prost(uint64, tag="2")] + pub virtual_memory: u64, + /// The STAT column of ps, such as Ss or R+, without L (locked pages). + #[prost(string, tag="3")] + pub state: ::prost::alloc::string::String, + /// CPU time of all the threads, in milliseconds. + #[prost(uint64, tag="4")] + pub user_time_ms: u64, + #[prost(uint64, tag="5")] + pub system_time_ms: u64, + /// Percent of one CPU since the previous scrape. + #[prost(float, tag="6")] + pub cpu_usage: f32, + #[prost(uint32, tag="7")] + pub threads: u32, + /// Page faults of all the threads. + #[prost(uint64, tag="8")] + pub minor_faults: u64, + #[prost(uint64, tag="9")] + pub major_faults: u64, + /// Unset where the zone kernel cannot count them cheaply (before Linux 6.2). + #[prost(uint32, optional, tag="10")] + pub open_files: ::core::option::Option, + /// As in /proc//stat: the kernel priority, the nice value, the policy + /// (SCHED_*) and the real-time priority. + #[prost(int32, tag="11")] + pub priority: i32, + #[prost(int32, tag="12")] + pub nice: i32, + #[prost(uint32, tag="13")] + pub policy: u32, + #[prost(uint32, tag="14")] + pub realtime_priority: u32, + /// The controlling terminal's device number (tty_nr), 0 for none. + #[prost(uint32, tag="15")] + pub terminal: u32, + #[prost(uint32, tag="16")] + pub session: u32, + #[prost(uint32, tag="17")] + pub process_group: u32, +} +/// The capability sets, each a mask by capability number. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ZoneProcessCapabilities { + #[prost(uint64, tag="1")] + pub inheritable: u64, + #[prost(uint64, tag="2")] + pub permitted: u64, + #[prost(uint64, tag="3")] + pub effective: u64, + #[prost(uint64, tag="4")] + pub bounding: u64, + #[prost(uint64, tag="5")] + pub ambient: u64, } +/// Subscribes to a snoop stream of all IDM traffic passing +/// between the daemon and zones on this host. Intended for debugging and analysis. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct SnoopIdmRequest { } +/// A batch of snooped IDM packets. If the subscriber falls behind the snoop buffer, +/// `skipped` reports how many packets were dropped to catch up. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SnoopIdmReply { #[prost(message, repeated, tag="1")] @@ -1755,6 +3156,8 @@ pub struct SnoopIdmReply { #[prost(uint64, tag="2")] pub skipped: u64, } +/// A single IDM packet. `from` and `to` are zone UUIDs (the host UUID stands in for the +/// daemon side), and `packet` is the protobuf-encoded IDM message. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct SnoopIdmPacket { #[prost(string, tag="1")] @@ -1764,10 +3167,52 @@ pub struct SnoopIdmPacket { #[prost(bytes="vec", tag="3")] pub packet: ::prost::alloc::vec::Vec, } +/// Request to snoop the Control API traffic for this host. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SnoopControlRequest { +} +/// Reply for the SnoopControl RPC, contains a batch of packets from the Control API. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SnoopControlReply { + /// Snooped packets that were received from the Control API. + #[prost(message, repeated, tag="1")] + pub packets: ::prost::alloc::vec::Vec, + /// Number of packets that were skipped due to buffer constraints. + #[prost(uint64, tag="2")] + pub skipped: u64, +} +/// / Represents a packet of data in/out of the Control API. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SnoopControlPacket { + /// Unique identifier for the packet. + #[prost(uint64, tag="1")] + pub id: u64, + /// Origin of the RPC. + #[prost(message, optional, tag="2")] + pub origin: ::core::option::Option, + /// Service name of the RPC. + #[prost(string, tag="3")] + pub service: ::prost::alloc::string::String, + /// Method name of the RPC. + #[prost(string, tag="4")] + pub method: ::prost::alloc::string::String, + /// Form of the packet. + #[prost(enumeration="SnoopControlPacketForm", tag="5")] + pub form: i32, + /// Payload of the packet. + #[prost(string, tag="6")] + pub payload: ::prost::alloc::string::String, + /// Whether the stream is closed. + #[prost(bool, tag="7")] + pub closed: bool, +} +/// Pulls an OCI image into the local image cache, packing it into the requested `format`. +/// `overwrite_cache` forces a fresh pull and repack even if the image is already cached. +/// `update` re-resolves the image reference against the registry (picking up new content +/// for moving tags) instead of resolving from the local cache. +/// Set `want_metadata` to receive the OCI manifest/config in the final reply. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct PullImageRequest { - #[prost(string, tag="1")] - pub image: ::prost::alloc::string::String, #[prost(enumeration="OciImageFormat", tag="2")] pub format: i32, #[prost(bool, tag="3")] @@ -1778,7 +3223,27 @@ pub struct PullImageRequest { pub want_metadata: bool, #[prost(message, optional, tag="6")] pub auth: ::core::option::Option, + /// The image to pull, given either as a literal OCI reference or as a named + /// kernel variant OCI alias the daemon resolves from its `\[zone.kernel-variants\]` + /// mapping in daemon.toml. + #[prost(oneof="pull_image_request::Source", tags="1, 7")] + pub source: ::core::option::Option, +} +/// Nested message and enum types in `PullImageRequest`. +pub mod pull_image_request { + /// The image to pull, given either as a literal OCI reference or as a named + /// kernel variant OCI alias the daemon resolves from its `\[zone.kernel-variants\]` + /// mapping in daemon.toml. + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Source { + #[prost(string, tag="1")] + Image(::prost::alloc::string::String), + #[prost(string, tag="7")] + KernelVariant(::prost::alloc::string::String), + } } +/// Streamed reply for `PullImageRequest`. Intermediate replies carry `progress` updates. +/// The final reply carries the packed image `spec`, plus `metadata` if requested. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PullImageReply { #[prost(message, optional, tag="1")] @@ -1788,6 +3253,34 @@ pub struct PullImageReply { #[prost(message, optional, tag="3")] pub metadata: ::core::option::Option, } +/// Lists the named zone kernel variants the daemon can resolve, as configured under +/// `\[zone.kernel-variants\]` in daemon.toml. These are the names accepted by the +/// `--kernel-variant` / `dev.edera/kernel-variant` selectors. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ListKernelVariantsRequest { +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListKernelVariantsReply { + #[prost(message, repeated, tag="1")] + pub variants: ::prost::alloc::vec::Vec, +} +/// A single named kernel variant: the selectable `name` and the OCI reference +/// the daemon resolves it to. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct KernelVariant { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub image: ::prost::alloc::string::String, +} +/// Client stream message for `ImportImage`: uploads an image archive directly into the +/// local image cache, as a sequence of `chunk`s with `last_chunk` set on the final one. +/// The first message must carry `image`, `digest` and `format`, identifying the image +/// and selecting the packed format to unpack it into. +/// +/// `local_path` replaces the `chunk` stream for a caller that shares a filesystem with +/// the daemon: it names a local OCI-layout directory for the daemon to read directly, in +/// a single request. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ImportImageRequest { #[prost(string, tag="1")] @@ -1804,7 +3297,16 @@ pub struct ImportImageRequest { pub overwrite_cache: bool, #[prost(bool, tag="7")] pub want_metadata: bool, + #[prost(string, tag="8")] + pub local_path: ::prost::alloc::string::String, + #[prost(string, optional, tag="9")] + pub source_digest: ::core::option::Option<::prost::alloc::string::String>, } +/// Streamed reply for `ImportImage`. `accepted` indicates whether the daemon will consume +/// the uploaded archive. It is `false` if a task for the same image is already active, in +/// which case the upload is ignored and this stream observes the existing task's progress +/// instead. As with `PullImageReply`, `progress` updates are followed by a final reply +/// carrying `spec`, plus `metadata` if requested. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ImportImageReply { #[prost(bool, tag="1")] @@ -1816,6 +3318,59 @@ pub struct ImportImageReply { #[prost(message, optional, tag="4")] pub metadata: ::core::option::Option, } +/// Client stream message for `ImportPackedImage`: stores an image the caller has already +/// packed into `format` directly in the local image cache, skipping the unpack and repack +/// that `ImportImage` performs. The daemon trusts the caller to have built the artifact +/// from the image `manifest` and `config` describe; it validates their shape and that +/// `digest` is the digest of `manifest`, but never the artifact's contents. +/// +/// The first message must carry `image`, `digest`, `format`, `manifest` and `config`. The +/// artifact follows as a sequence of `chunk`s with `last_chunk` set on the final one (a +/// tar archive for `OCI_IMAGE_FORMAT_DIRECTORY`). `local_path` replaces the `chunk` stream +/// for a caller that shares a filesystem with the daemon: it names the artifact, which must +/// be staged under the daemon's temporary directory and which the daemon moves into the +/// cache, in a single request. When the image is already cached and `overwrite_cache` is +/// unset, the artifact is left untouched. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ImportPackedImageRequest { + #[prost(string, tag="1")] + pub image: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub digest: ::prost::alloc::string::String, + #[prost(enumeration="OciImageFormat", tag="3")] + pub format: i32, + #[prost(bytes="vec", tag="4")] + pub manifest: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="5")] + pub config: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="6")] + pub chunk: ::prost::alloc::vec::Vec, + #[prost(bool, tag="7")] + pub last_chunk: bool, + #[prost(string, tag="8")] + pub local_path: ::prost::alloc::string::String, + #[prost(bool, tag="9")] + pub overwrite_cache: bool, + /// A squashfs blob that another store owns. The daemon links its cache entry to the + /// blob and never moves or deletes it. When set, chunk, last_chunk and local_path are ignored. + #[prost(message, optional, tag="10")] + pub linked_blob: ::core::option::Option, +} +/// The blob `/blobs/sha256/` of `digest`, where `root` is the path that the +/// daemon config maps `store` to under `\[oci.external-stores\]`. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct LinkedBlob { + #[prost(string, tag="1")] + pub store: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub digest: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ImportPackedImageReply { + #[prost(message, optional, tag="1")] + pub spec: ::core::option::Option, +} +/// Removes the image identified by `digest` and `format` from the local image cache. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct RemoveImageRequest { #[prost(string, tag="1")] @@ -1823,35 +3378,105 @@ pub struct RemoveImageRequest { #[prost(enumeration="OciImageFormat", tag="2")] pub format: i32, } +/// `removed` indicates whether the image existed and was removed. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct RemoveImageReply { #[prost(bool, tag="1")] pub removed: bool, } +/// Removes each cached image whose linked blob is gone, unless a workload uses it. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct PruneImagesRequest { +} +/// The images that were removed. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PruneImagesReply { + #[prost(message, repeated, tag="1")] + pub removed: ::prost::alloc::vec::Vec, +} +/// Lists all images currently present in the local image cache. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ListImagesRequest { } +/// A streamed batch of cached images. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListImagesReply { #[prost(message, repeated, tag="1")] pub images: ::prost::alloc::vec::Vec, } +/// Lists host devices available for passthrough to zones, including whether each device +/// is currently claimed, and by which zone. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ListDevicesRequest { } +/// The set of known host devices. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListDevicesReply { #[prost(message, repeated, tag="1")] pub devices: ::prost::alloc::vec::Vec, } +/// Requests the host CPU topology. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetHostCpuTopologyRequest { } +/// One entry per logical host CPU, describing its core/socket/node/thread placement +/// and CPU class. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetHostCpuTopologyReply { #[prost(message, repeated, tag="1")] pub cpus: ::prost::alloc::vec::Vec, } +/// Requests aggregate memory, CPU, and topology figures for this machine. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetHostResourcesRequest { +} +/// Memory, CPU, and topology figures for this machine. `hypervisor_*` values +/// describe the whole machine as the hypervisor sees it; `host_*` values +/// describe the host (dom0) that Edera runs in. +/// +/// Memory figures are in bytes. CPU usage is the busy fraction as a percentage +/// (0-100); CPU total time is the cumulative elapsed CPU time since boot, summed +/// across all logical CPUs, in nanoseconds. Core counts are physical cores; see +/// GetHostCpuTopology for the per-CPU breakdown. +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct GetHostResourcesReply { + #[prost(uint64, tag="1")] + pub hypervisor_total_memory: u64, + #[prost(uint64, tag="2")] + pub hypervisor_used_memory: u64, + #[prost(uint64, tag="3")] + pub hypervisor_free_memory: u64, + #[prost(double, tag="4")] + pub hypervisor_cpu_usage: f64, + #[prost(uint64, tag="5")] + pub hypervisor_cpu_total_time: u64, + #[prost(uint32, tag="6")] + pub hypervisor_numa_nodes: u32, + #[prost(uint32, tag="7")] + pub hypervisor_cpu_sockets: u32, + #[prost(uint32, tag="8")] + pub hypervisor_cpu_cores: u32, + #[prost(uint32, tag="17")] + pub hypervisor_cpu_threads: u32, + #[prost(uint64, tag="9")] + pub host_total_memory: u64, + #[prost(uint64, tag="10")] + pub host_used_memory: u64, + #[prost(uint64, tag="11")] + pub host_free_memory: u64, + #[prost(double, tag="12")] + pub host_cpu_usage: f64, + #[prost(uint64, tag="13")] + pub host_cpu_total_time: u64, + #[prost(uint32, tag="14")] + pub host_numa_nodes: u32, + #[prost(uint32, tag="15")] + pub host_cpu_sockets: u32, + #[prost(uint32, tag="16")] + pub host_cpu_cores: u32, +} +/// Sets the host power management policy. `scheduler` is a CPU frequency governor name, +/// applied to all host CPUs. `smt_awareness` toggles SMT-aware power management. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct SetHostPowerManagementPolicyRequest { #[prost(string, tag="1")] @@ -1862,7 +3487,9 @@ pub struct SetHostPowerManagementPolicyRequest { #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct SetHostPowerManagementPolicyReply { } -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +/// Live-updates the CPU and memory resources of a running zone, within the resource +/// bounds the zone was created with. +#[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateZoneResourcesRequest { #[prost(string, tag="1")] pub zone_id: ::prost::alloc::string::String, @@ -1872,30 +3499,39 @@ pub struct UpdateZoneResourcesRequest { #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct UpdateZoneResourcesReply { } +/// Reads the accumulated dmesg-style hypervisor console log. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadHypervisorConsoleRequest { } +/// The hypervisor console log contents. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ReadHypervisorConsoleReply { #[prost(string, tag="1")] pub data: ::prost::alloc::string::String, } +/// Lists all current network reservations. See `CreateNetworkReservationRequest`. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ListNetworkReservationsRequest { } +/// A streamed batch of network reservations. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListNetworkReservationsReply { #[prost(message, repeated, tag="1")] pub reservations: ::prost::alloc::vec::Vec, } +/// Allocates a new network reservation: a MAC address and IPv4/IPv6 assignment reserved +/// ahead of zone creation. A zone can later be created against the reservation via +/// `ZoneNetworkOptionsSpec.assume_network_reservation`. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct CreateNetworkReservationRequest { } +/// The newly allocated reservation. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct CreateNetworkReservationReply { #[prost(message, optional, tag="1")] pub reservation: ::core::option::Option, } +/// Releases the network reservation with the given UUID. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DestroyNetworkReservationRequest { #[prost(string, tag="1")] @@ -1904,24 +3540,31 @@ pub struct DestroyNetworkReservationRequest { #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct DestroyNetworkReservationReply { } +/// Requests hypervisor debug state. Intended for debugging. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct HypervisorDebugInfoRequest { } +/// Hypervisor debug state, as free-form JSON whose shape may change between versions. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct HypervisorDebugInfoReply { #[prost(string, tag="1")] pub json: ::prost::alloc::string::String, } +/// Creates a new workload in an existing zone (specified by `WorkloadSpec.zone_id`). +/// Creating a workload does not start it, see `StartWorkloadRequest`. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateWorkloadRequest { #[prost(message, optional, tag="1")] pub spec: ::core::option::Option, } +/// If `CreateWorkloadRequest` was successful, returns the UUID of the created workload, +/// which may be retained by the caller as an identifier for future workload-related RPCs. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct CreateWorkloadReply { #[prost(string, tag="1")] pub workload_id: ::prost::alloc::string::String, } +/// Starts a previously created workload. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct StartWorkloadRequest { #[prost(string, tag="1")] @@ -1930,6 +3573,8 @@ pub struct StartWorkloadRequest { #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct StartWorkloadReply { } +/// Stops a running workload. The workload process is asked to terminate gracefully, and +/// is forcibly killed if it has not exited after `timeout` seconds. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct StopWorkloadRequest { #[prost(string, tag="1")] @@ -1940,6 +3585,8 @@ pub struct StopWorkloadRequest { #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct StopWorkloadReply { } +/// Destroys an existing workload, stopping it if necessary and releasing any resources +/// allocated to it. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DestroyWorkloadRequest { #[prost(string, tag="1")] @@ -1948,44 +3595,69 @@ pub struct DestroyWorkloadRequest { #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct DestroyWorkloadReply { } +/// Live-updates the cgroup limits of an existing workload. Each named limit replaces the +/// workload's current value; limits the request does not name keep theirs. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpdateWorkloadResourcesRequest { + #[prost(string, tag="1")] + pub workload_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag="2")] + pub cgroup_limits: ::prost::alloc::vec::Vec, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UpdateWorkloadResourcesReply { +} +/// Resolves workload "friendly name" to a singular workload UUID, if possible. Matching is exact. +/// See also `ResolveWorkloadIdsRequest` (plural). #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ResolveWorkloadIdRequest { #[prost(string, tag="1")] pub name: ::prost::alloc::string::String, } +/// The UUID of the workload matching the requested name. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ResolveWorkloadIdReply { #[prost(string, tag="1")] pub workload_id: ::prost::alloc::string::String, } +/// In cases where multiple workloads share the same "friendly name", return a list of all +/// distinct workload_ids that match that "friendly name". Matching is exact. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ResolveWorkloadIdsRequest { #[prost(string, tag="1")] pub name: ::prost::alloc::string::String, } +/// The UUIDs of all workloads matching the requested name. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ResolveWorkloadIdsReply { #[prost(string, repeated, tag="1")] pub workload_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } +/// List all workloads currently managed by Edera, across all zones. As with +/// `ListZonesRequest`, this includes workloads that are no longer running or in a +/// failed state, as well as running workloads. #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] pub struct ListWorkloadsRequest { } +/// A streamed batch of workloads. The full workload list is the concatenation of all streamed replies. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListWorkloadsReply { #[prost(message, repeated, tag="1")] pub workloads: ::prost::alloc::vec::Vec, } +/// Request detailed workload information for a given workload UUID. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct GetWorkloadRequest { #[prost(string, tag="1")] pub workload_id: ::prost::alloc::string::String, } +/// Detailed workload information for the requested workload. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetWorkloadReply { #[prost(message, optional, tag="1")] pub workload: ::core::option::Option, } +/// Applies a network configuration (interfaces, routes, neighbor entries) to an existing zone. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ConfigureZoneNetworkRequest { #[prost(string, tag="1")] @@ -1997,6 +3669,26 @@ pub struct ConfigureZoneNetworkRequest { pub struct ConfigureZoneNetworkReply { } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct AdvertiseZoneServiceRequest { + #[prost(string, tag="1")] + pub uuid: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub config: ::core::option::Option, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct AdvertiseZoneServiceReply { +} +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UnadvertiseZoneServiceRequest { + #[prost(message, optional, tag="2")] + pub config: ::core::option::Option, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UnadvertiseZoneServiceReply { +} +/// Client stream message for `DialNetworkSocket`. The first message must be a +/// `DialNetworkSocketStart`. Subsequent messages carry data to write to the connection. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DialNetworkSocketRequest { #[prost(oneof="dial_network_socket_request::Request", tags="1, 2")] pub request: ::core::option::Option, @@ -2011,6 +3703,8 @@ pub mod dial_network_socket_request { Data(super::DialNetworkSocketData), } } +/// Dials a TCP connection to `address:port` from inside the specified zone's network. +/// Once established, the stream acts as a bidirectional byte proxy for the connection. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DialNetworkSocketStart { #[prost(string, tag="1")] @@ -2020,16 +3714,206 @@ pub struct DialNetworkSocketStart { #[prost(uint32, tag="3")] pub port: u32, } +/// A chunk of connection payload bytes. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DialNetworkSocketData { #[prost(bytes="vec", tag="1")] pub content: ::prost::alloc::vec::Vec, } +/// A chunk of bytes received from the zone-side connection. #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct DialNetworkSocketReply { #[prost(message, optional, tag="1")] pub data: ::core::option::Option, } +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DialObjectCapabilityRequest { + #[prost(oneof="dial_object_capability_request::Request", tags="1, 2")] + pub request: ::core::option::Option, +} +/// Nested message and enum types in `DialObjectCapabilityRequest`. +pub mod dial_object_capability_request { + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Request { + #[prost(message, tag="1")] + Start(super::DialObjectCapabilityStart), + #[prost(message, tag="2")] + Data(super::DialObjectCapabilityData), + } +} +/// Dials the object capability requested as `name`, which the daemon resolves to +/// a running provider and its zone. Once established, the stream is a +/// bidirectional byte proxy carrying one capsudo session (descriptor passing is +/// simulated over it). +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DialObjectCapabilityStart { + /// The capability requested: either an implementation's own identity or a + /// capability type declared in some publish's `implements`. + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + /// Optional attribution: the workload this call is made on behalf of, for the + /// provider's audit/policy. Empty for a direct external caller (the daemon + /// attributes those via the control-API principal). + #[prost(string, tag="2")] + pub caller_workload_id: ::prost::alloc::string::String, + /// Optional pin: require the implementation published under this name. Empty + /// selects the highest-priority running provider of `name`. + #[prost(string, tag="3")] + pub provider: ::prost::alloc::string::String, +} +/// A chunk of capsudo session bytes sent toward the capability. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DialObjectCapabilityData { + #[prost(bytes="vec", tag="1")] + pub content: ::prost::alloc::vec::Vec, +} +/// A chunk of capsudo session bytes received from the capability. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DialObjectCapabilityReply { + #[prost(message, optional, tag="1")] + pub data: ::core::option::Option, +} +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ListObjectCapabilitiesRequest { +} +/// A streamed batch of published object capabilities. The full list is the +/// concatenation of all streamed replies. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListObjectCapabilitiesReply { + #[prost(message, repeated, tag="1")] + pub object_capabilities: ::prost::alloc::vec::Vec, +} +/// How `ReplicateZone` makes its copies. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ZoneReplicateMode { + /// The daemon picks fork when the zone and the backend support it, and + /// export/import otherwise. + Automatic = 0, + /// Memory-shared copies, made as `ForkZone` makes them. + Fork = 1, + /// The zone is exported to a file on the host, and each replica is imported + /// from that file as `ImportZone` imports it. + ExportImport = 2, +} +impl ZoneReplicateMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Automatic => "ZONE_REPLICATE_MODE_AUTOMATIC", + Self::Fork => "ZONE_REPLICATE_MODE_FORK", + Self::ExportImport => "ZONE_REPLICATE_MODE_EXPORT_IMPORT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ZONE_REPLICATE_MODE_AUTOMATIC" => Some(Self::Automatic), + "ZONE_REPLICATE_MODE_FORK" => Some(Self::Fork), + "ZONE_REPLICATE_MODE_EXPORT_IMPORT" => Some(Self::ExportImport), + _ => None, + } + } +} +/// What a mount that has no host path yet is bound to until a container +/// supplies it. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum RestoredPlaceholder { + Unspecified = 0, + File = 1, + Directory = 2, +} +impl RestoredPlaceholder { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "RESTORED_PLACEHOLDER_UNSPECIFIED", + Self::File => "RESTORED_PLACEHOLDER_FILE", + Self::Directory => "RESTORED_PLACEHOLDER_DIRECTORY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RESTORED_PLACEHOLDER_UNSPECIFIED" => Some(Self::Unspecified), + "RESTORED_PLACEHOLDER_FILE" => Some(Self::File), + "RESTORED_PLACEHOLDER_DIRECTORY" => Some(Self::Directory), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ZoneKernelNetworkProtocol { + Unspecified = 0, + Tcp = 1, + Udp = 2, +} +impl ZoneKernelNetworkProtocol { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "ZONE_KERNEL_NETWORK_PROTOCOL_UNSPECIFIED", + Self::Tcp => "ZONE_KERNEL_NETWORK_PROTOCOL_TCP", + Self::Udp => "ZONE_KERNEL_NETWORK_PROTOCOL_UDP", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ZONE_KERNEL_NETWORK_PROTOCOL_UNSPECIFIED" => Some(Self::Unspecified), + "ZONE_KERNEL_NETWORK_PROTOCOL_TCP" => Some(Self::Tcp), + "ZONE_KERNEL_NETWORK_PROTOCOL_UDP" => Some(Self::Udp), + _ => None, + } + } +} +/// Which side started a connection or flow. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ZoneKernelNetworkDirection { + /// Not known: a UDP flow on a socket that existed before the network source + /// loaded, whose first datagram may not have been seen. + Unspecified = 0, + /// The zone's process started it: it called connect(), or sent a UDP flow's + /// first datagram. + Outbound = 1, + /// A peer started it: the zone's process accepted the connection, or received + /// a UDP flow's first datagram. + Inbound = 2, +} +impl ZoneKernelNetworkDirection { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "ZONE_KERNEL_NETWORK_DIRECTION_UNSPECIFIED", + Self::Outbound => "ZONE_KERNEL_NETWORK_DIRECTION_OUTBOUND", + Self::Inbound => "ZONE_KERNEL_NETWORK_DIRECTION_INBOUND", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ZONE_KERNEL_NETWORK_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified), + "ZONE_KERNEL_NETWORK_DIRECTION_OUTBOUND" => Some(Self::Outbound), + "ZONE_KERNEL_NETWORK_DIRECTION_INBOUND" => Some(Self::Inbound), + _ => None, + } + } +} #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ZoneKernelFdType { @@ -2154,6 +4038,39 @@ impl ZoneKernelIpProtocol { } } } +/// / Represents the form of a packet in the Control API. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum SnoopControlPacketForm { + Unknown = 0, + Request = 1, + Error = 2, + Response = 3, +} +impl SnoopControlPacketForm { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unknown => "SNOOP_CONTROL_PACKET_FORM_UNKNOWN", + Self::Request => "SNOOP_CONTROL_PACKET_FORM_REQUEST", + Self::Error => "SNOOP_CONTROL_PACKET_FORM_ERROR", + Self::Response => "SNOOP_CONTROL_PACKET_FORM_RESPONSE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SNOOP_CONTROL_PACKET_FORM_UNKNOWN" => Some(Self::Unknown), + "SNOOP_CONTROL_PACKET_FORM_REQUEST" => Some(Self::Request), + "SNOOP_CONTROL_PACKET_FORM_ERROR" => Some(Self::Error), + "SNOOP_CONTROL_PACKET_FORM_RESPONSE" => Some(Self::Response), + _ => None, + } + } +} include!("protect.control.v1.serde.rs"); include!("protect.control.v1.tonic.rs"); // @@protoc_insertion_point(module) \ No newline at end of file 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 0d2286b..c92cfea 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 @@ -1,43 +1,27 @@ // @generated -impl serde::Serialize for AnnotationSpec { +impl serde::Serialize for AdoptWorkloadReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.key.is_empty() { - len += 1; - } - if !self.value.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.AnnotationSpec", len)?; - if !self.key.is_empty() { - struct_ser.serialize_field("key", &self.key)?; - } - if !self.value.is_empty() { - struct_ser.serialize_field("value", &self.value)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.AdoptWorkloadReply", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for AnnotationSpec { +impl<'de> serde::Deserialize<'de> for AdoptWorkloadReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "key", - "value", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Key, - Value, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -58,11 +42,7 @@ impl<'de> serde::Deserialize<'de> for AnnotationSpec { where E: serde::de::Error, { - match value { - "key" => Ok(GeneratedField::Key), - "value" => Ok(GeneratedField::Value), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -70,44 +50,27 @@ impl<'de> serde::Deserialize<'de> for AnnotationSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AnnotationSpec; + type Value = AdoptWorkloadReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.AnnotationSpec") + formatter.write_str("struct protect.control.v1.AdoptWorkloadReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut key__ = None; - let mut value__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Key => { - if key__.is_some() { - return Err(serde::de::Error::duplicate_field("key")); - } - key__ = Some(map_.next_value()?); - } - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); - } - value__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(AnnotationSpec { - key: key__.unwrap_or_default(), - value: value__.unwrap_or_default(), + Ok(AdoptWorkloadReply { }) } } - deserializer.deserialize_struct("protect.control.v1.AnnotationSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.AdoptWorkloadReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for BlockDeviceMountOptions { +impl serde::Serialize for AdoptWorkloadRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -115,37 +78,73 @@ impl serde::Serialize for BlockDeviceMountOptions { { use serde::ser::SerializeStruct; let mut len = 0; - if self.readonly { + if !self.zone_id.is_empty() { len += 1; } - if !self.permissions.is_empty() { + if !self.workload_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.BlockDeviceMountOptions", len)?; - if self.readonly { - struct_ser.serialize_field("readonly", &self.readonly)?; + if !self.container_id.is_empty() { + len += 1; } - if !self.permissions.is_empty() { - struct_ser.serialize_field("permissions", &self.permissions)?; + if !self.sandbox_id.is_empty() { + len += 1; + } + if !self.mounts.is_empty() { + len += 1; + } + if !self.annotations.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.AdoptWorkloadRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; + } + if !self.container_id.is_empty() { + struct_ser.serialize_field("containerId", &self.container_id)?; + } + if !self.sandbox_id.is_empty() { + struct_ser.serialize_field("sandboxId", &self.sandbox_id)?; + } + if !self.mounts.is_empty() { + struct_ser.serialize_field("mounts", &self.mounts)?; + } + if !self.annotations.is_empty() { + struct_ser.serialize_field("annotations", &self.annotations)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for BlockDeviceMountOptions { +impl<'de> serde::Deserialize<'de> for AdoptWorkloadRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "readonly", - "permissions", + "zone_id", + "zoneId", + "workload_id", + "workloadId", + "container_id", + "containerId", + "sandbox_id", + "sandboxId", + "mounts", + "annotations", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Readonly, - Permissions, + ZoneId, + WorkloadId, + ContainerId, + SandboxId, + Mounts, + Annotations, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -167,8 +166,12 @@ impl<'de> serde::Deserialize<'de> for BlockDeviceMountOptions { E: serde::de::Error, { match value { - "readonly" => Ok(GeneratedField::Readonly), - "permissions" => Ok(GeneratedField::Permissions), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "containerId" | "container_id" => Ok(GeneratedField::ContainerId), + "sandboxId" | "sandbox_id" => Ok(GeneratedField::SandboxId), + "mounts" => Ok(GeneratedField::Mounts), + "annotations" => Ok(GeneratedField::Annotations), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -178,44 +181,76 @@ impl<'de> serde::Deserialize<'de> for BlockDeviceMountOptions { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = BlockDeviceMountOptions; + type Value = AdoptWorkloadRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.BlockDeviceMountOptions") + formatter.write_str("struct protect.control.v1.AdoptWorkloadRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut readonly__ = None; - let mut permissions__ = None; + let mut zone_id__ = None; + let mut workload_id__ = None; + let mut container_id__ = None; + let mut sandbox_id__ = None; + let mut mounts__ = None; + let mut annotations__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Readonly => { - if readonly__.is_some() { - return Err(serde::de::Error::duplicate_field("readonly")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - readonly__ = Some(map_.next_value()?); + zone_id__ = Some(map_.next_value()?); } - GeneratedField::Permissions => { - if permissions__.is_some() { - return Err(serde::de::Error::duplicate_field("permissions")); + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); } - permissions__ = Some(map_.next_value()?); + workload_id__ = Some(map_.next_value()?); + } + GeneratedField::ContainerId => { + if container_id__.is_some() { + return Err(serde::de::Error::duplicate_field("containerId")); + } + container_id__ = Some(map_.next_value()?); + } + GeneratedField::SandboxId => { + if sandbox_id__.is_some() { + return Err(serde::de::Error::duplicate_field("sandboxId")); + } + sandbox_id__ = Some(map_.next_value()?); + } + GeneratedField::Mounts => { + if mounts__.is_some() { + return Err(serde::de::Error::duplicate_field("mounts")); + } + mounts__ = Some(map_.next_value()?); + } + GeneratedField::Annotations => { + if annotations__.is_some() { + return Err(serde::de::Error::duplicate_field("annotations")); + } + annotations__ = Some(map_.next_value()?); } } } - Ok(BlockDeviceMountOptions { - readonly: readonly__.unwrap_or_default(), - permissions: permissions__.unwrap_or_default(), + Ok(AdoptWorkloadRequest { + zone_id: zone_id__.unwrap_or_default(), + workload_id: workload_id__.unwrap_or_default(), + container_id: container_id__.unwrap_or_default(), + sandbox_id: sandbox_id__.unwrap_or_default(), + mounts: mounts__.unwrap_or_default(), + annotations: annotations__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.BlockDeviceMountOptions", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.AdoptWorkloadRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CgroupLimit { +impl serde::Serialize for AdvertiseServiceEvent { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -223,38 +258,30 @@ impl serde::Serialize for CgroupLimit { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.limit_name.is_empty() { - len += 1; - } - if !self.value.is_empty() { + if self.service_entry.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.CgroupLimit", len)?; - if !self.limit_name.is_empty() { - struct_ser.serialize_field("limitName", &self.limit_name)?; - } - if !self.value.is_empty() { - struct_ser.serialize_field("value", &self.value)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.AdvertiseServiceEvent", len)?; + if let Some(v) = self.service_entry.as_ref() { + struct_ser.serialize_field("serviceEntry", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CgroupLimit { +impl<'de> serde::Deserialize<'de> for AdvertiseServiceEvent { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "limit_name", - "limitName", - "value", + "service_entry", + "serviceEntry", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - LimitName, - Value, + ServiceEntry, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -276,8 +303,7 @@ impl<'de> serde::Deserialize<'de> for CgroupLimit { E: serde::de::Error, { match value { - "limitName" | "limit_name" => Ok(GeneratedField::LimitName), - "value" => Ok(GeneratedField::Value), + "serviceEntry" | "service_entry" => Ok(GeneratedField::ServiceEntry), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -287,44 +313,36 @@ impl<'de> serde::Deserialize<'de> for CgroupLimit { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CgroupLimit; + type Value = AdvertiseServiceEvent; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.CgroupLimit") + formatter.write_str("struct protect.control.v1.AdvertiseServiceEvent") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut limit_name__ = None; - let mut value__ = None; + let mut service_entry__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::LimitName => { - if limit_name__.is_some() { - return Err(serde::de::Error::duplicate_field("limitName")); - } - limit_name__ = Some(map_.next_value()?); - } - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); + GeneratedField::ServiceEntry => { + if service_entry__.is_some() { + return Err(serde::de::Error::duplicate_field("serviceEntry")); } - value__ = Some(map_.next_value()?); + service_entry__ = map_.next_value()?; } } } - Ok(CgroupLimit { - limit_name: limit_name__.unwrap_or_default(), - value: value__.unwrap_or_default(), + Ok(AdvertiseServiceEvent { + service_entry: service_entry__, }) } } - deserializer.deserialize_struct("protect.control.v1.CgroupLimit", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.AdvertiseServiceEvent", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ConfigureZoneNetworkReply { +impl serde::Serialize for AdvertiseZoneServiceReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -332,11 +350,11 @@ impl serde::Serialize for ConfigureZoneNetworkReply { { use serde::ser::SerializeStruct; let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.ConfigureZoneNetworkReply", len)?; + let struct_ser = serializer.serialize_struct("protect.control.v1.AdvertiseZoneServiceReply", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ConfigureZoneNetworkReply { +impl<'de> serde::Deserialize<'de> for AdvertiseZoneServiceReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where @@ -375,27 +393,27 @@ impl<'de> serde::Deserialize<'de> for ConfigureZoneNetworkReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ConfigureZoneNetworkReply; + type Value = AdvertiseZoneServiceReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ConfigureZoneNetworkReply") + formatter.write_str("struct protect.control.v1.AdvertiseZoneServiceReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(ConfigureZoneNetworkReply { + Ok(AdvertiseZoneServiceReply { }) } } - deserializer.deserialize_struct("protect.control.v1.ConfigureZoneNetworkReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.AdvertiseZoneServiceReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ConfigureZoneNetworkRequest { +impl serde::Serialize for AdvertiseZoneServiceRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -403,15 +421,15 @@ impl serde::Serialize for ConfigureZoneNetworkRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { + if !self.uuid.is_empty() { len += 1; } if self.config.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ConfigureZoneNetworkRequest", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.AdvertiseZoneServiceRequest", len)?; + if !self.uuid.is_empty() { + struct_ser.serialize_field("uuid", &self.uuid)?; } if let Some(v) = self.config.as_ref() { struct_ser.serialize_field("config", v)?; @@ -419,21 +437,20 @@ impl serde::Serialize for ConfigureZoneNetworkRequest { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ConfigureZoneNetworkRequest { +impl<'de> serde::Deserialize<'de> for AdvertiseZoneServiceRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", + "uuid", "config", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, + Uuid, Config, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -456,7 +473,7 @@ impl<'de> serde::Deserialize<'de> for ConfigureZoneNetworkRequest { E: serde::de::Error, { match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "uuid" => Ok(GeneratedField::Uuid), "config" => Ok(GeneratedField::Config), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -467,25 +484,25 @@ impl<'de> serde::Deserialize<'de> for ConfigureZoneNetworkRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ConfigureZoneNetworkRequest; + type Value = AdvertiseZoneServiceRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ConfigureZoneNetworkRequest") + formatter.write_str("struct protect.control.v1.AdvertiseZoneServiceRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; + let mut uuid__ = None; let mut config__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); + GeneratedField::Uuid => { + if uuid__.is_some() { + return Err(serde::de::Error::duplicate_field("uuid")); } - zone_id__ = Some(map_.next_value()?); + uuid__ = Some(map_.next_value()?); } GeneratedField::Config => { if config__.is_some() { @@ -495,46 +512,38 @@ impl<'de> serde::Deserialize<'de> for ConfigureZoneNetworkRequest { } } } - Ok(ConfigureZoneNetworkRequest { - zone_id: zone_id__.unwrap_or_default(), + Ok(AdvertiseZoneServiceRequest { + uuid: uuid__.unwrap_or_default(), config: config__, }) } } - deserializer.deserialize_struct("protect.control.v1.ConfigureZoneNetworkRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.AdvertiseZoneServiceRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateNetworkReservationReply { +impl serde::Serialize for AllVcpus { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if self.reservation.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateNetworkReservationReply", len)?; - if let Some(v) = self.reservation.as_ref() { - struct_ser.serialize_field("reservation", v)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.AllVcpus", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateNetworkReservationReply { +impl<'de> serde::Deserialize<'de> for AllVcpus { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "reservation", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Reservation, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -555,10 +564,7 @@ impl<'de> serde::Deserialize<'de> for CreateNetworkReservationReply { where E: serde::de::Error, { - match value { - "reservation" => Ok(GeneratedField::Reservation), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -566,58 +572,65 @@ impl<'de> serde::Deserialize<'de> for CreateNetworkReservationReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateNetworkReservationReply; + type Value = AllVcpus; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.CreateNetworkReservationReply") + formatter.write_str("struct protect.control.v1.AllVcpus") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut reservation__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Reservation => { - if reservation__.is_some() { - return Err(serde::de::Error::duplicate_field("reservation")); - } - reservation__ = map_.next_value()?; - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(CreateNetworkReservationReply { - reservation: reservation__, + Ok(AllVcpus { }) } } - deserializer.deserialize_struct("protect.control.v1.CreateNetworkReservationReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.AllVcpus", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateNetworkReservationRequest { +impl serde::Serialize for AnnotationSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.CreateNetworkReservationRequest", len)?; + let mut len = 0; + if !self.key.is_empty() { + len += 1; + } + if !self.value.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.AnnotationSpec", len)?; + if !self.key.is_empty() { + struct_ser.serialize_field("key", &self.key)?; + } + if !self.value.is_empty() { + struct_ser.serialize_field("value", &self.value)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateNetworkReservationRequest { +impl<'de> serde::Deserialize<'de> for AnnotationSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "key", + "value", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Key, + Value, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -638,7 +651,11 @@ impl<'de> serde::Deserialize<'de> for CreateNetworkReservationRequest { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "key" => Ok(GeneratedField::Key), + "value" => Ok(GeneratedField::Value), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -646,27 +663,115 @@ impl<'de> serde::Deserialize<'de> for CreateNetworkReservationRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateNetworkReservationRequest; + type Value = AnnotationSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.CreateNetworkReservationRequest") + formatter.write_str("struct protect.control.v1.AnnotationSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut key__ = None; + let mut value__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); + } + key__ = Some(map_.next_value()?); + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = Some(map_.next_value()?); + } + } } - Ok(CreateNetworkReservationRequest { + Ok(AnnotationSpec { + key: key__.unwrap_or_default(), + value: value__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.CreateNetworkReservationRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.AnnotationSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateWorkloadReply { +impl serde::Serialize for AppArmorProfileType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unconfined => "APP_ARMOR_PROFILE_TYPE_UNCONFINED", + Self::RuntimeDefault => "APP_ARMOR_PROFILE_TYPE_RUNTIME_DEFAULT", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for AppArmorProfileType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "APP_ARMOR_PROFILE_TYPE_UNCONFINED", + "APP_ARMOR_PROFILE_TYPE_RUNTIME_DEFAULT", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AppArmorProfileType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "APP_ARMOR_PROFILE_TYPE_UNCONFINED" => Ok(AppArmorProfileType::Unconfined), + "APP_ARMOR_PROFILE_TYPE_RUNTIME_DEFAULT" => Ok(AppArmorProfileType::RuntimeDefault), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for BlockDeviceMountOptions { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -674,30 +779,37 @@ impl serde::Serialize for CreateWorkloadReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.workload_id.is_empty() { + if self.readonly { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateWorkloadReply", len)?; - if !self.workload_id.is_empty() { - struct_ser.serialize_field("workloadId", &self.workload_id)?; + if !self.permissions.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.BlockDeviceMountOptions", len)?; + if self.readonly { + struct_ser.serialize_field("readonly", &self.readonly)?; + } + if !self.permissions.is_empty() { + struct_ser.serialize_field("permissions", &self.permissions)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateWorkloadReply { +impl<'de> serde::Deserialize<'de> for BlockDeviceMountOptions { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload_id", - "workloadId", + "readonly", + "permissions", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WorkloadId, + Readonly, + Permissions, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -719,7 +831,8 @@ impl<'de> serde::Deserialize<'de> for CreateWorkloadReply { E: serde::de::Error, { match value { - "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "readonly" => Ok(GeneratedField::Readonly), + "permissions" => Ok(GeneratedField::Permissions), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -729,36 +842,44 @@ impl<'de> serde::Deserialize<'de> for CreateWorkloadReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateWorkloadReply; + type Value = BlockDeviceMountOptions; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.CreateWorkloadReply") + formatter.write_str("struct protect.control.v1.BlockDeviceMountOptions") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload_id__ = None; + let mut readonly__ = None; + let mut permissions__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::WorkloadId => { - if workload_id__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadId")); + GeneratedField::Readonly => { + if readonly__.is_some() { + return Err(serde::de::Error::duplicate_field("readonly")); } - workload_id__ = Some(map_.next_value()?); + readonly__ = Some(map_.next_value()?); + } + GeneratedField::Permissions => { + if permissions__.is_some() { + return Err(serde::de::Error::duplicate_field("permissions")); + } + permissions__ = Some(map_.next_value()?); } } } - Ok(CreateWorkloadReply { - workload_id: workload_id__.unwrap_or_default(), + Ok(BlockDeviceMountOptions { + readonly: readonly__.unwrap_or_default(), + permissions: permissions__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.CreateWorkloadReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.BlockDeviceMountOptions", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateWorkloadRequest { +impl serde::Serialize for CapturedMountRef { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -766,29 +887,39 @@ impl serde::Serialize for CreateWorkloadRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if self.spec.is_some() { + if !self.workload_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateWorkloadRequest", len)?; - if let Some(v) = self.spec.as_ref() { - struct_ser.serialize_field("spec", v)?; + if !self.target_path.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.CapturedMountRef", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; + } + if !self.target_path.is_empty() { + struct_ser.serialize_field("targetPath", &self.target_path)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateWorkloadRequest { +impl<'de> serde::Deserialize<'de> for CapturedMountRef { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "spec", + "workload_id", + "workloadId", + "target_path", + "targetPath", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Spec, + WorkloadId, + TargetPath, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -810,7 +941,8 @@ impl<'de> serde::Deserialize<'de> for CreateWorkloadRequest { E: serde::de::Error, { match value { - "spec" => Ok(GeneratedField::Spec), + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "targetPath" | "target_path" => Ok(GeneratedField::TargetPath), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -820,36 +952,44 @@ impl<'de> serde::Deserialize<'de> for CreateWorkloadRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateWorkloadRequest; + type Value = CapturedMountRef; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.CreateWorkloadRequest") + formatter.write_str("struct protect.control.v1.CapturedMountRef") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut spec__ = None; + let mut workload_id__ = None; + let mut target_path__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Spec => { - if spec__.is_some() { - return Err(serde::de::Error::duplicate_field("spec")); + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); } - spec__ = map_.next_value()?; + workload_id__ = Some(map_.next_value()?); + } + GeneratedField::TargetPath => { + if target_path__.is_some() { + return Err(serde::de::Error::duplicate_field("targetPath")); + } + target_path__ = Some(map_.next_value()?); } } } - Ok(CreateWorkloadRequest { - spec: spec__, + Ok(CapturedMountRef { + workload_id: workload_id__.unwrap_or_default(), + target_path: target_path__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.CreateWorkloadRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.CapturedMountRef", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateZoneReply { +impl serde::Serialize for CgroupLimit { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -857,30 +997,38 @@ impl serde::Serialize for CreateZoneReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { + if !self.limit_name.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateZoneReply", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; + if !self.value.is_empty() { + len += 1; } - struct_ser.end() + let mut struct_ser = serializer.serialize_struct("protect.control.v1.CgroupLimit", len)?; + if !self.limit_name.is_empty() { + struct_ser.serialize_field("limitName", &self.limit_name)?; + } + if !self.value.is_empty() { + struct_ser.serialize_field("value", &self.value)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateZoneReply { +impl<'de> serde::Deserialize<'de> for CgroupLimit { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", + "limit_name", + "limitName", + "value", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, + LimitName, + Value, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -902,7 +1050,8 @@ impl<'de> serde::Deserialize<'de> for CreateZoneReply { E: serde::de::Error, { match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "limitName" | "limit_name" => Ok(GeneratedField::LimitName), + "value" => Ok(GeneratedField::Value), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -912,36 +1061,44 @@ impl<'de> serde::Deserialize<'de> for CreateZoneReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateZoneReply; + type Value = CgroupLimit; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.CreateZoneReply") + formatter.write_str("struct protect.control.v1.CgroupLimit") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; + let mut limit_name__ = None; + let mut value__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); + GeneratedField::LimitName => { + if limit_name__.is_some() { + return Err(serde::de::Error::duplicate_field("limitName")); } - zone_id__ = Some(map_.next_value()?); + limit_name__ = Some(map_.next_value()?); + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = Some(map_.next_value()?); } } } - Ok(CreateZoneReply { - zone_id: zone_id__.unwrap_or_default(), + Ok(CgroupLimit { + limit_name: limit_name__.unwrap_or_default(), + value: value__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.CreateZoneReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.CgroupLimit", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateZoneRequest { +impl serde::Serialize for ClaimRestoredZoneReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -949,29 +1106,46 @@ impl serde::Serialize for CreateZoneRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if self.spec.is_some() { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateZoneRequest", len)?; - if let Some(v) = self.spec.as_ref() { - struct_ser.serialize_field("spec", v)?; + if !self.workloads.is_empty() { + len += 1; + } + if !self.annotations.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ClaimRestoredZoneReply", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.workloads.is_empty() { + struct_ser.serialize_field("workloads", &self.workloads)?; + } + if !self.annotations.is_empty() { + struct_ser.serialize_field("annotations", &self.annotations)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateZoneRequest { +impl<'de> serde::Deserialize<'de> for ClaimRestoredZoneReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "spec", + "zone_id", + "zoneId", + "workloads", + "annotations", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Spec, + ZoneId, + Workloads, + Annotations, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -993,7 +1167,9 @@ impl<'de> serde::Deserialize<'de> for CreateZoneRequest { E: serde::de::Error, { match value { - "spec" => Ok(GeneratedField::Spec), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "workloads" => Ok(GeneratedField::Workloads), + "annotations" => Ok(GeneratedField::Annotations), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1003,107 +1179,52 @@ impl<'de> serde::Deserialize<'de> for CreateZoneRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateZoneRequest; + type Value = ClaimRestoredZoneReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.CreateZoneRequest") + formatter.write_str("struct protect.control.v1.ClaimRestoredZoneReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut spec__ = None; + let mut zone_id__ = None; + let mut workloads__ = None; + let mut annotations__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Spec => { - if spec__.is_some() { - return Err(serde::de::Error::duplicate_field("spec")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - spec__ = map_.next_value()?; + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Workloads => { + if workloads__.is_some() { + return Err(serde::de::Error::duplicate_field("workloads")); + } + workloads__ = Some(map_.next_value()?); + } + GeneratedField::Annotations => { + if annotations__.is_some() { + return Err(serde::de::Error::duplicate_field("annotations")); + } + annotations__ = Some(map_.next_value()?); } } } - Ok(CreateZoneRequest { - spec: spec__, - }) - } - } - deserializer.deserialize_struct("protect.control.v1.CreateZoneRequest", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for DestroyNetworkReservationReply { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.DestroyNetworkReservationReply", len)?; - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for DestroyNetworkReservationReply { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - } - 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, - { - Err(serde::de::Error::unknown_field(value, FIELDS)) - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DestroyNetworkReservationReply; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DestroyNetworkReservationReply") - } - - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; - } - Ok(DestroyNetworkReservationReply { + Ok(ClaimRestoredZoneReply { + zone_id: zone_id__.unwrap_or_default(), + workloads: workloads__.unwrap_or_default(), + annotations: annotations__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.DestroyNetworkReservationReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ClaimRestoredZoneReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DestroyNetworkReservationRequest { +impl serde::Serialize for ClaimRestoredZoneRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -1111,30 +1232,29 @@ impl serde::Serialize for DestroyNetworkReservationRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.reservation_id.is_empty() { + if !self.claim.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.DestroyNetworkReservationRequest", len)?; - if !self.reservation_id.is_empty() { - struct_ser.serialize_field("reservationId", &self.reservation_id)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ClaimRestoredZoneRequest", len)?; + if !self.claim.is_empty() { + struct_ser.serialize_field("claim", &self.claim)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DestroyNetworkReservationRequest { +impl<'de> serde::Deserialize<'de> for ClaimRestoredZoneRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "reservation_id", - "reservationId", + "claim", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ReservationId, + Claim, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1156,7 +1276,7 @@ impl<'de> serde::Deserialize<'de> for DestroyNetworkReservationRequest { E: serde::de::Error, { match value { - "reservationId" | "reservation_id" => Ok(GeneratedField::ReservationId), + "claim" => Ok(GeneratedField::Claim), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1166,36 +1286,36 @@ impl<'de> serde::Deserialize<'de> for DestroyNetworkReservationRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DestroyNetworkReservationRequest; + type Value = ClaimRestoredZoneRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DestroyNetworkReservationRequest") + formatter.write_str("struct protect.control.v1.ClaimRestoredZoneRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut reservation_id__ = None; + let mut claim__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ReservationId => { - if reservation_id__.is_some() { - return Err(serde::de::Error::duplicate_field("reservationId")); + GeneratedField::Claim => { + if claim__.is_some() { + return Err(serde::de::Error::duplicate_field("claim")); } - reservation_id__ = Some(map_.next_value()?); + claim__ = Some(map_.next_value()?); } } } - Ok(DestroyNetworkReservationRequest { - reservation_id: reservation_id__.unwrap_or_default(), + Ok(ClaimRestoredZoneRequest { + claim: claim__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.DestroyNetworkReservationRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ClaimRestoredZoneRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DestroyWorkloadReply { +impl serde::Serialize for ConfigureZoneNetworkReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -1203,11 +1323,11 @@ impl serde::Serialize for DestroyWorkloadReply { { use serde::ser::SerializeStruct; let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.DestroyWorkloadReply", len)?; + let struct_ser = serializer.serialize_struct("protect.control.v1.ConfigureZoneNetworkReply", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DestroyWorkloadReply { +impl<'de> serde::Deserialize<'de> for ConfigureZoneNetworkReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where @@ -1246,27 +1366,27 @@ impl<'de> serde::Deserialize<'de> for DestroyWorkloadReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DestroyWorkloadReply; + type Value = ConfigureZoneNetworkReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DestroyWorkloadReply") + formatter.write_str("struct protect.control.v1.ConfigureZoneNetworkReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(DestroyWorkloadReply { + Ok(ConfigureZoneNetworkReply { }) } } - deserializer.deserialize_struct("protect.control.v1.DestroyWorkloadReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ConfigureZoneNetworkReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DestroyWorkloadRequest { +impl serde::Serialize for ConfigureZoneNetworkRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -1274,30 +1394,38 @@ impl serde::Serialize for DestroyWorkloadRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.workload_id.is_empty() { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.DestroyWorkloadRequest", len)?; - if !self.workload_id.is_empty() { - struct_ser.serialize_field("workloadId", &self.workload_id)?; + if self.config.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ConfigureZoneNetworkRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if let Some(v) = self.config.as_ref() { + struct_ser.serialize_field("config", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DestroyWorkloadRequest { +impl<'de> serde::Deserialize<'de> for ConfigureZoneNetworkRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload_id", - "workloadId", + "zone_id", + "zoneId", + "config", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WorkloadId, + ZoneId, + Config, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1319,7 +1447,8 @@ impl<'de> serde::Deserialize<'de> for DestroyWorkloadRequest { E: serde::de::Error, { match value { - "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "config" => Ok(GeneratedField::Config), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1329,58 +1458,74 @@ impl<'de> serde::Deserialize<'de> for DestroyWorkloadRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DestroyWorkloadRequest; + type Value = ConfigureZoneNetworkRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DestroyWorkloadRequest") + formatter.write_str("struct protect.control.v1.ConfigureZoneNetworkRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload_id__ = None; + let mut zone_id__ = None; + let mut config__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::WorkloadId => { - if workload_id__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadId")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - workload_id__ = Some(map_.next_value()?); + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Config => { + if config__.is_some() { + return Err(serde::de::Error::duplicate_field("config")); + } + config__ = map_.next_value()?; } } } - Ok(DestroyWorkloadRequest { - workload_id: workload_id__.unwrap_or_default(), + Ok(ConfigureZoneNetworkRequest { + zone_id: zone_id__.unwrap_or_default(), + config: config__, }) } } - deserializer.deserialize_struct("protect.control.v1.DestroyWorkloadRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ConfigureZoneNetworkRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DestroyZoneReply { +impl serde::Serialize for CreateNetworkReservationReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.DestroyZoneReply", len)?; + let mut len = 0; + if self.reservation.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateNetworkReservationReply", len)?; + if let Some(v) = self.reservation.as_ref() { + struct_ser.serialize_field("reservation", v)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DestroyZoneReply { +impl<'de> serde::Deserialize<'de> for CreateNetworkReservationReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "reservation", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Reservation, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1401,7 +1546,10 @@ impl<'de> serde::Deserialize<'de> for DestroyZoneReply { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "reservation" => Ok(GeneratedField::Reservation), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -1409,58 +1557,58 @@ impl<'de> serde::Deserialize<'de> for DestroyZoneReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DestroyZoneReply; + type Value = CreateNetworkReservationReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DestroyZoneReply") + formatter.write_str("struct protect.control.v1.CreateNetworkReservationReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut reservation__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Reservation => { + if reservation__.is_some() { + return Err(serde::de::Error::duplicate_field("reservation")); + } + reservation__ = map_.next_value()?; + } + } } - Ok(DestroyZoneReply { + Ok(CreateNetworkReservationReply { + reservation: reservation__, }) } } - deserializer.deserialize_struct("protect.control.v1.DestroyZoneReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.CreateNetworkReservationReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DestroyZoneRequest { +impl serde::Serialize for CreateNetworkReservationRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.zone_id.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.DestroyZoneRequest", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.CreateNetworkReservationRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DestroyZoneRequest { +impl<'de> serde::Deserialize<'de> for CreateNetworkReservationRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1481,10 +1629,7 @@ impl<'de> serde::Deserialize<'de> for DestroyZoneRequest { where E: serde::de::Error, { - match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -1492,36 +1637,27 @@ impl<'de> serde::Deserialize<'de> for DestroyZoneRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DestroyZoneRequest; + type Value = CreateNetworkReservationRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DestroyZoneRequest") + formatter.write_str("struct protect.control.v1.CreateNetworkReservationRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); - } - zone_id__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(DestroyZoneRequest { - zone_id: zone_id__.unwrap_or_default(), + Ok(CreateNetworkReservationRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.DestroyZoneRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.CreateNetworkReservationRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DeviceInfo { +impl serde::Serialize for CreateWorkloadReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -1529,46 +1665,30 @@ impl serde::Serialize for DeviceInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if self.claimed { - len += 1; - } - if !self.owner_zone.is_empty() { + if !self.workload_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.DeviceInfo", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if self.claimed { - struct_ser.serialize_field("claimed", &self.claimed)?; - } - if !self.owner_zone.is_empty() { - struct_ser.serialize_field("ownerZone", &self.owner_zone)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateWorkloadReply", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DeviceInfo { +impl<'de> serde::Deserialize<'de> for CreateWorkloadReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", - "claimed", - "owner_zone", - "ownerZone", + "workload_id", + "workloadId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, - Claimed, - OwnerZone, + WorkloadId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1590,9 +1710,7 @@ impl<'de> serde::Deserialize<'de> for DeviceInfo { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), - "claimed" => Ok(GeneratedField::Claimed), - "ownerZone" | "owner_zone" => Ok(GeneratedField::OwnerZone), + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1602,52 +1720,36 @@ impl<'de> serde::Deserialize<'de> for DeviceInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DeviceInfo; + type Value = CreateWorkloadReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DeviceInfo") + formatter.write_str("struct protect.control.v1.CreateWorkloadReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; - let mut claimed__ = None; - let mut owner_zone__ = None; + let mut workload_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map_.next_value()?); - } - GeneratedField::Claimed => { - if claimed__.is_some() { - return Err(serde::de::Error::duplicate_field("claimed")); - } - claimed__ = Some(map_.next_value()?); - } - GeneratedField::OwnerZone => { - if owner_zone__.is_some() { - return Err(serde::de::Error::duplicate_field("ownerZone")); + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); } - owner_zone__ = Some(map_.next_value()?); + workload_id__ = Some(map_.next_value()?); } } } - Ok(DeviceInfo { - name: name__.unwrap_or_default(), - claimed: claimed__.unwrap_or_default(), - owner_zone: owner_zone__.unwrap_or_default(), + Ok(CreateWorkloadReply { + workload_id: workload_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.DeviceInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.CreateWorkloadReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DeviceReferenceSpec { +impl serde::Serialize for CreateWorkloadRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -1655,29 +1757,29 @@ impl serde::Serialize for DeviceReferenceSpec { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { + if self.spec.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.DeviceReferenceSpec", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateWorkloadRequest", len)?; + if let Some(v) = self.spec.as_ref() { + struct_ser.serialize_field("spec", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DeviceReferenceSpec { +impl<'de> serde::Deserialize<'de> for CreateWorkloadRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", + "spec", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, + Spec, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1699,7 +1801,7 @@ impl<'de> serde::Deserialize<'de> for DeviceReferenceSpec { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), + "spec" => Ok(GeneratedField::Spec), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1709,36 +1811,36 @@ impl<'de> serde::Deserialize<'de> for DeviceReferenceSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DeviceReferenceSpec; + type Value = CreateWorkloadRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DeviceReferenceSpec") + formatter.write_str("struct protect.control.v1.CreateWorkloadRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; + let mut spec__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); + GeneratedField::Spec => { + if spec__.is_some() { + return Err(serde::de::Error::duplicate_field("spec")); } - name__ = Some(map_.next_value()?); + spec__ = map_.next_value()?; } } } - Ok(DeviceReferenceSpec { - name: name__.unwrap_or_default(), + Ok(CreateWorkloadRequest { + spec: spec__, }) } } - deserializer.deserialize_struct("protect.control.v1.DeviceReferenceSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.CreateWorkloadRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DialNetworkSocketData { +impl serde::Serialize for CreateZoneReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -1746,31 +1848,30 @@ impl serde::Serialize for DialNetworkSocketData { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.content.is_empty() { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialNetworkSocketData", len)?; - if !self.content.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("content", pbjson::private::base64::encode(&self.content).as_str())?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateZoneReply", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DialNetworkSocketData { +impl<'de> serde::Deserialize<'de> for CreateZoneReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "content", + "zone_id", + "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Content, + ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1792,7 +1893,7 @@ impl<'de> serde::Deserialize<'de> for DialNetworkSocketData { E: serde::de::Error, { match value { - "content" => Ok(GeneratedField::Content), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1802,38 +1903,36 @@ impl<'de> serde::Deserialize<'de> for DialNetworkSocketData { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DialNetworkSocketData; + type Value = CreateZoneReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DialNetworkSocketData") + formatter.write_str("struct protect.control.v1.CreateZoneReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut content__ = None; + let mut zone_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Content => { - if content__.is_some() { - return Err(serde::de::Error::duplicate_field("content")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - content__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + zone_id__ = Some(map_.next_value()?); } } } - Ok(DialNetworkSocketData { - content: content__.unwrap_or_default(), + Ok(CreateZoneReply { + zone_id: zone_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.DialNetworkSocketData", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.CreateZoneReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DialNetworkSocketReply { +impl serde::Serialize for CreateZoneRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -1841,29 +1940,29 @@ impl serde::Serialize for DialNetworkSocketReply { { use serde::ser::SerializeStruct; let mut len = 0; - if self.data.is_some() { + if self.spec.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialNetworkSocketReply", len)?; - if let Some(v) = self.data.as_ref() { - struct_ser.serialize_field("data", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.CreateZoneRequest", len)?; + if let Some(v) = self.spec.as_ref() { + struct_ser.serialize_field("spec", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DialNetworkSocketReply { +impl<'de> serde::Deserialize<'de> for CreateZoneRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "data", + "spec", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Data, + Spec, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1885,7 +1984,7 @@ impl<'de> serde::Deserialize<'de> for DialNetworkSocketReply { E: serde::de::Error, { match value { - "data" => Ok(GeneratedField::Data), + "spec" => Ok(GeneratedField::Spec), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1895,75 +1994,58 @@ impl<'de> serde::Deserialize<'de> for DialNetworkSocketReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DialNetworkSocketReply; + type Value = CreateZoneRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DialNetworkSocketReply") + formatter.write_str("struct protect.control.v1.CreateZoneRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut data__ = None; + let mut spec__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Data => { - if data__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); + GeneratedField::Spec => { + if spec__.is_some() { + return Err(serde::de::Error::duplicate_field("spec")); } - data__ = map_.next_value()?; + spec__ = map_.next_value()?; } } } - Ok(DialNetworkSocketReply { - data: data__, + Ok(CreateZoneRequest { + spec: spec__, }) } } - deserializer.deserialize_struct("protect.control.v1.DialNetworkSocketReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.CreateZoneRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DialNetworkSocketRequest { +impl serde::Serialize for DestroyNetworkReservationReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if self.request.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialNetworkSocketRequest", len)?; - if let Some(v) = self.request.as_ref() { - match v { - dial_network_socket_request::Request::Start(v) => { - struct_ser.serialize_field("start", v)?; - } - dial_network_socket_request::Request::Data(v) => { - struct_ser.serialize_field("data", v)?; - } - } - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.DestroyNetworkReservationReply", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DialNetworkSocketRequest { +impl<'de> serde::Deserialize<'de> for DestroyNetworkReservationReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "start", - "data", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Start, - Data, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1984,11 +2066,7 @@ impl<'de> serde::Deserialize<'de> for DialNetworkSocketRequest { where E: serde::de::Error, { - match value { - "start" => Ok(GeneratedField::Start), - "data" => Ok(GeneratedField::Data), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -1996,44 +2074,27 @@ impl<'de> serde::Deserialize<'de> for DialNetworkSocketRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DialNetworkSocketRequest; + type Value = DestroyNetworkReservationReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DialNetworkSocketRequest") + formatter.write_str("struct protect.control.v1.DestroyNetworkReservationReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut request__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Start => { - if request__.is_some() { - return Err(serde::de::Error::duplicate_field("start")); - } - request__ = map_.next_value::<::std::option::Option<_>>()?.map(dial_network_socket_request::Request::Start) -; - } - GeneratedField::Data => { - if request__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); - } - request__ = map_.next_value::<::std::option::Option<_>>()?.map(dial_network_socket_request::Request::Data) -; - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(DialNetworkSocketRequest { - request: request__, + Ok(DestroyNetworkReservationReply { }) } } - deserializer.deserialize_struct("protect.control.v1.DialNetworkSocketRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DestroyNetworkReservationReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DialNetworkSocketStart { +impl serde::Serialize for DestroyNetworkReservationRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2041,46 +2102,30 @@ impl serde::Serialize for DialNetworkSocketStart { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { - len += 1; - } - if !self.address.is_empty() { - len += 1; - } - if self.port != 0 { + if !self.reservation_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialNetworkSocketStart", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; - } - if !self.address.is_empty() { - struct_ser.serialize_field("address", &self.address)?; - } - if self.port != 0 { - struct_ser.serialize_field("port", &self.port)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DestroyNetworkReservationRequest", len)?; + if !self.reservation_id.is_empty() { + struct_ser.serialize_field("reservationId", &self.reservation_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DialNetworkSocketStart { +impl<'de> serde::Deserialize<'de> for DestroyNetworkReservationRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", - "address", - "port", + "reservation_id", + "reservationId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, - Address, - Port, + ReservationId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2102,9 +2147,7 @@ impl<'de> serde::Deserialize<'de> for DialNetworkSocketStart { E: serde::de::Error, { match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - "address" => Ok(GeneratedField::Address), - "port" => Ok(GeneratedField::Port), + "reservationId" | "reservation_id" => Ok(GeneratedField::ReservationId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2114,92 +2157,58 @@ impl<'de> serde::Deserialize<'de> for DialNetworkSocketStart { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DialNetworkSocketStart; + type Value = DestroyNetworkReservationRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.DialNetworkSocketStart") + formatter.write_str("struct protect.control.v1.DestroyNetworkReservationRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - let mut address__ = None; - let mut port__ = None; + let mut reservation_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); - } - zone_id__ = Some(map_.next_value()?); - } - GeneratedField::Address => { - if address__.is_some() { - return Err(serde::de::Error::duplicate_field("address")); - } - address__ = Some(map_.next_value()?); - } - GeneratedField::Port => { - if port__.is_some() { - return Err(serde::de::Error::duplicate_field("port")); + GeneratedField::ReservationId => { + if reservation_id__.is_some() { + return Err(serde::de::Error::duplicate_field("reservationId")); } - port__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + reservation_id__ = Some(map_.next_value()?); } } } - Ok(DialNetworkSocketStart { - zone_id: zone_id__.unwrap_or_default(), - address: address__.unwrap_or_default(), - port: port__.unwrap_or_default(), + Ok(DestroyNetworkReservationRequest { + reservation_id: reservation_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.DialNetworkSocketStart", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DestroyNetworkReservationRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for EnvironmentVariableSpec { +impl serde::Serialize for DestroyWorkloadReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.key.is_empty() { - len += 1; - } - if !self.value.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.EnvironmentVariableSpec", len)?; - if !self.key.is_empty() { - struct_ser.serialize_field("key", &self.key)?; - } - if !self.value.is_empty() { - struct_ser.serialize_field("value", &self.value)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.DestroyWorkloadReply", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for EnvironmentVariableSpec { +impl<'de> serde::Deserialize<'de> for DestroyWorkloadReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "key", - "value", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Key, - Value, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2220,11 +2229,7 @@ impl<'de> serde::Deserialize<'de> for EnvironmentVariableSpec { where E: serde::de::Error, { - match value { - "key" => Ok(GeneratedField::Key), - "value" => Ok(GeneratedField::Value), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -2232,44 +2237,27 @@ impl<'de> serde::Deserialize<'de> for EnvironmentVariableSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = EnvironmentVariableSpec; + type Value = DestroyWorkloadReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.EnvironmentVariableSpec") + formatter.write_str("struct protect.control.v1.DestroyWorkloadReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut key__ = None; - let mut value__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Key => { - if key__.is_some() { - return Err(serde::de::Error::duplicate_field("key")); - } - key__ = Some(map_.next_value()?); - } - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); - } - value__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(EnvironmentVariableSpec { - key: key__.unwrap_or_default(), - value: value__.unwrap_or_default(), + Ok(DestroyWorkloadReply { }) } } - deserializer.deserialize_struct("protect.control.v1.EnvironmentVariableSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DestroyWorkloadReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ExecuteZoneCommandExited { +impl serde::Serialize for DestroyWorkloadRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2277,30 +2265,30 @@ impl serde::Serialize for ExecuteZoneCommandExited { { use serde::ser::SerializeStruct; let mut len = 0; - if self.exit_code != 0 { + if !self.workload_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandExited", len)?; - if self.exit_code != 0 { - struct_ser.serialize_field("exitCode", &self.exit_code)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DestroyWorkloadRequest", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandExited { +impl<'de> serde::Deserialize<'de> for DestroyWorkloadRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "exit_code", - "exitCode", + "workload_id", + "workloadId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ExitCode, + WorkloadId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2322,7 +2310,7 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandExited { E: serde::de::Error, { match value { - "exitCode" | "exit_code" => Ok(GeneratedField::ExitCode), + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2332,80 +2320,58 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandExited { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExecuteZoneCommandExited; + type Value = DestroyWorkloadRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ExecuteZoneCommandExited") + formatter.write_str("struct protect.control.v1.DestroyWorkloadRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut exit_code__ = None; + let mut workload_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ExitCode => { - if exit_code__.is_some() { - return Err(serde::de::Error::duplicate_field("exitCode")); + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); } - exit_code__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + workload_id__ = Some(map_.next_value()?); } } } - Ok(ExecuteZoneCommandExited { - exit_code: exit_code__.unwrap_or_default(), + Ok(DestroyWorkloadRequest { + workload_id: workload_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandExited", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DestroyWorkloadRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ExecuteZoneCommandOutput { +impl serde::Serialize for DestroyZoneReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.stdout.is_empty() { - len += 1; - } - if !self.stderr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandOutput", len)?; - if !self.stdout.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("stdout", pbjson::private::base64::encode(&self.stdout).as_str())?; - } - if !self.stderr.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("stderr", pbjson::private::base64::encode(&self.stderr).as_str())?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.DestroyZoneReply", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandOutput { +impl<'de> serde::Deserialize<'de> for DestroyZoneReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "stdout", - "stderr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Stdout, - Stderr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2426,11 +2392,7 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandOutput { where E: serde::de::Error, { - match value { - "stdout" => Ok(GeneratedField::Stdout), - "stderr" => Ok(GeneratedField::Stderr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -2438,48 +2400,27 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandOutput { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExecuteZoneCommandOutput; + type Value = DestroyZoneReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ExecuteZoneCommandOutput") + formatter.write_str("struct protect.control.v1.DestroyZoneReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut stdout__ = None; - let mut stderr__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Stdout => { - if stdout__.is_some() { - return Err(serde::de::Error::duplicate_field("stdout")); - } - stdout__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::Stderr => { - if stderr__.is_some() { - return Err(serde::de::Error::duplicate_field("stderr")); - } - stderr__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(ExecuteZoneCommandOutput { - stdout: stdout__.unwrap_or_default(), - stderr: stderr__.unwrap_or_default(), + Ok(DestroyZoneReply { }) } } - deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandOutput", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DestroyZoneReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ExecuteZoneCommandReply { +impl serde::Serialize for DestroyZoneRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2487,38 +2428,30 @@ impl serde::Serialize for ExecuteZoneCommandReply { { use serde::ser::SerializeStruct; let mut len = 0; - if self.reply.is_some() { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandReply", len)?; - if let Some(v) = self.reply.as_ref() { - match v { - execute_zone_command_reply::Reply::Output(v) => { - struct_ser.serialize_field("output", v)?; - } - execute_zone_command_reply::Reply::Exited(v) => { - struct_ser.serialize_field("exited", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DestroyZoneRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandReply { +impl<'de> serde::Deserialize<'de> for DestroyZoneRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "output", - "exited", + "zone_id", + "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Output, - Exited, + ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2540,8 +2473,7 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandReply { E: serde::de::Error, { match value { - "output" => Ok(GeneratedField::Output), - "exited" => Ok(GeneratedField::Exited), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2551,44 +2483,36 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExecuteZoneCommandReply; + type Value = DestroyZoneRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ExecuteZoneCommandReply") + formatter.write_str("struct protect.control.v1.DestroyZoneRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut reply__ = None; + let mut zone_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Output => { - if reply__.is_some() { - return Err(serde::de::Error::duplicate_field("output")); - } - reply__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_reply::Reply::Output) -; - } - GeneratedField::Exited => { - if reply__.is_some() { - return Err(serde::de::Error::duplicate_field("exited")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - reply__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_reply::Reply::Exited) -; + zone_id__ = Some(map_.next_value()?); } } } - Ok(ExecuteZoneCommandReply { - reply: reply__, + Ok(DestroyZoneRequest { + zone_id: zone_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DestroyZoneRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ExecuteZoneCommandRequest { +impl serde::Serialize for DeviceInfo { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2596,44 +2520,46 @@ impl serde::Serialize for ExecuteZoneCommandRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if self.request.is_some() { + if !self.name.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandRequest", len)?; - if let Some(v) = self.request.as_ref() { - match v { - execute_zone_command_request::Request::Start(v) => { - struct_ser.serialize_field("start", v)?; - } - execute_zone_command_request::Request::Stdin(v) => { - struct_ser.serialize_field("stdin", v)?; - } - execute_zone_command_request::Request::TerminalResize(v) => { - struct_ser.serialize_field("terminalResize", v)?; - } - } + if self.claimed { + len += 1; + } + if !self.owner_zone.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DeviceInfo", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if self.claimed { + struct_ser.serialize_field("claimed", &self.claimed)?; + } + if !self.owner_zone.is_empty() { + struct_ser.serialize_field("ownerZone", &self.owner_zone)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandRequest { +impl<'de> serde::Deserialize<'de> for DeviceInfo { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "start", - "stdin", - "terminal_resize", - "terminalResize", + "name", + "claimed", + "owner_zone", + "ownerZone", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Start, - Stdin, - TerminalResize, + Name, + Claimed, + OwnerZone, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2655,9 +2581,9 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandRequest { E: serde::de::Error, { match value { - "start" => Ok(GeneratedField::Start), - "stdin" => Ok(GeneratedField::Stdin), - "terminalResize" | "terminal_resize" => Ok(GeneratedField::TerminalResize), + "name" => Ok(GeneratedField::Name), + "claimed" => Ok(GeneratedField::Claimed), + "ownerZone" | "owner_zone" => Ok(GeneratedField::OwnerZone), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2667,51 +2593,52 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExecuteZoneCommandRequest; + type Value = DeviceInfo; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ExecuteZoneCommandRequest") + formatter.write_str("struct protect.control.v1.DeviceInfo") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut request__ = None; + let mut name__ = None; + let mut claimed__ = None; + let mut owner_zone__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Start => { - if request__.is_some() { - return Err(serde::de::Error::duplicate_field("start")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - request__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_request::Request::Start) -; + name__ = Some(map_.next_value()?); } - GeneratedField::Stdin => { - if request__.is_some() { - return Err(serde::de::Error::duplicate_field("stdin")); + GeneratedField::Claimed => { + if claimed__.is_some() { + return Err(serde::de::Error::duplicate_field("claimed")); } - request__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_request::Request::Stdin) -; + claimed__ = Some(map_.next_value()?); } - GeneratedField::TerminalResize => { - if request__.is_some() { - return Err(serde::de::Error::duplicate_field("terminalResize")); + GeneratedField::OwnerZone => { + if owner_zone__.is_some() { + return Err(serde::de::Error::duplicate_field("ownerZone")); } - request__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_request::Request::TerminalResize) -; + owner_zone__ = Some(map_.next_value()?); } } } - Ok(ExecuteZoneCommandRequest { - request: request__, + Ok(DeviceInfo { + name: name__.unwrap_or_default(), + claimed: claimed__.unwrap_or_default(), + owner_zone: owner_zone__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DeviceInfo", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ExecuteZoneCommandStart { +impl serde::Serialize for DeviceReferenceSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2719,47 +2646,29 @@ impl serde::Serialize for ExecuteZoneCommandStart { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { - len += 1; - } - if !self.workload_id.is_empty() { - len += 1; - } - if self.process.is_some() { + if !self.name.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandStart", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; - } - if !self.workload_id.is_empty() { - struct_ser.serialize_field("workloadId", &self.workload_id)?; - } - if let Some(v) = self.process.as_ref() { - struct_ser.serialize_field("process", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DeviceReferenceSpec", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandStart { +impl<'de> serde::Deserialize<'de> for DeviceReferenceSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", - "workload_id", - "workloadId", - "process", + "name", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, - WorkloadId, - Process, + Name, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2781,9 +2690,7 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandStart { E: serde::de::Error, { match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), - "process" => Ok(GeneratedField::Process), + "name" => Ok(GeneratedField::Name), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2793,52 +2700,36 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandStart { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExecuteZoneCommandStart; + type Value = DeviceReferenceSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ExecuteZoneCommandStart") + formatter.write_str("struct protect.control.v1.DeviceReferenceSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - let mut workload_id__ = None; - let mut process__ = None; + let mut name__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); - } - zone_id__ = Some(map_.next_value()?); - } - GeneratedField::WorkloadId => { - if workload_id__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadId")); - } - workload_id__ = Some(map_.next_value()?); - } - GeneratedField::Process => { - if process__.is_some() { - return Err(serde::de::Error::duplicate_field("process")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - process__ = map_.next_value()?; + name__ = Some(map_.next_value()?); } } } - Ok(ExecuteZoneCommandStart { - zone_id: zone_id__.unwrap_or_default(), - workload_id: workload_id__.unwrap_or_default(), - process: process__, + Ok(DeviceReferenceSpec { + name: name__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandStart", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DeviceReferenceSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ExecuteZoneCommandStdin { +impl serde::Serialize for DialNetworkSocketData { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2846,39 +2737,31 @@ impl serde::Serialize for ExecuteZoneCommandStdin { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.stdin.is_empty() { - len += 1; - } - if self.closed { + if !self.content.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandStdin", len)?; - if !self.stdin.is_empty() { + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialNetworkSocketData", len)?; + if !self.content.is_empty() { #[allow(clippy::needless_borrow)] #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("stdin", pbjson::private::base64::encode(&self.stdin).as_str())?; - } - if self.closed { - struct_ser.serialize_field("closed", &self.closed)?; + struct_ser.serialize_field("content", pbjson::private::base64::encode(&self.content).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandStdin { +impl<'de> serde::Deserialize<'de> for DialNetworkSocketData { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "stdin", - "closed", + "content", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Stdin, - Closed, + Content, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2900,8 +2783,7 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandStdin { E: serde::de::Error, { match value { - "stdin" => Ok(GeneratedField::Stdin), - "closed" => Ok(GeneratedField::Closed), + "content" => Ok(GeneratedField::Content), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2911,46 +2793,38 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandStdin { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExecuteZoneCommandStdin; + type Value = DialNetworkSocketData; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ExecuteZoneCommandStdin") + formatter.write_str("struct protect.control.v1.DialNetworkSocketData") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut stdin__ = None; - let mut closed__ = None; + let mut content__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Stdin => { - if stdin__.is_some() { - return Err(serde::de::Error::duplicate_field("stdin")); + GeneratedField::Content => { + if content__.is_some() { + return Err(serde::de::Error::duplicate_field("content")); } - stdin__ = + content__ = Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } - GeneratedField::Closed => { - if closed__.is_some() { - return Err(serde::de::Error::duplicate_field("closed")); - } - closed__ = Some(map_.next_value()?); - } } } - Ok(ExecuteZoneCommandStdin { - stdin: stdin__.unwrap_or_default(), - closed: closed__.unwrap_or_default(), + Ok(DialNetworkSocketData { + content: content__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandStdin", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DialNetworkSocketData", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ExecuteZoneCommandTerminalResize { +impl serde::Serialize for DialNetworkSocketReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2958,29 +2832,29 @@ impl serde::Serialize for ExecuteZoneCommandTerminalResize { { use serde::ser::SerializeStruct; let mut len = 0; - if self.size.is_some() { + if self.data.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandTerminalResize", len)?; - if let Some(v) = self.size.as_ref() { - struct_ser.serialize_field("size", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialNetworkSocketReply", len)?; + if let Some(v) = self.data.as_ref() { + struct_ser.serialize_field("data", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandTerminalResize { +impl<'de> serde::Deserialize<'de> for DialNetworkSocketReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "size", + "data", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Size, + Data, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3002,7 +2876,7 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandTerminalResize { E: serde::de::Error, { match value { - "size" => Ok(GeneratedField::Size), + "data" => Ok(GeneratedField::Data), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3012,36 +2886,36 @@ impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandTerminalResize { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExecuteZoneCommandTerminalResize; + type Value = DialNetworkSocketReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ExecuteZoneCommandTerminalResize") + formatter.write_str("struct protect.control.v1.DialNetworkSocketReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut size__ = None; + let mut data__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Size => { - if size__.is_some() { - return Err(serde::de::Error::duplicate_field("size")); + GeneratedField::Data => { + if data__.is_some() { + return Err(serde::de::Error::duplicate_field("data")); } - size__ = map_.next_value()?; + data__ = map_.next_value()?; } } } - Ok(ExecuteZoneCommandTerminalResize { - size: size__, + Ok(DialNetworkSocketReply { + data: data__, }) } } - deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandTerminalResize", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DialNetworkSocketReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetHostCpuTopologyReply { +impl serde::Serialize for DialNetworkSocketRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3049,29 +2923,38 @@ impl serde::Serialize for GetHostCpuTopologyReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.cpus.is_empty() { + if self.request.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetHostCpuTopologyReply", len)?; - if !self.cpus.is_empty() { - struct_ser.serialize_field("cpus", &self.cpus)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialNetworkSocketRequest", len)?; + if let Some(v) = self.request.as_ref() { + match v { + dial_network_socket_request::Request::Start(v) => { + struct_ser.serialize_field("start", v)?; + } + dial_network_socket_request::Request::Data(v) => { + struct_ser.serialize_field("data", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetHostCpuTopologyReply { +impl<'de> serde::Deserialize<'de> for DialNetworkSocketRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "cpus", + "start", + "data", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Cpus, + Start, + Data, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3093,7 +2976,8 @@ impl<'de> serde::Deserialize<'de> for GetHostCpuTopologyReply { E: serde::de::Error, { match value { - "cpus" => Ok(GeneratedField::Cpus), + "start" => Ok(GeneratedField::Start), + "data" => Ok(GeneratedField::Data), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3103,58 +2987,91 @@ impl<'de> serde::Deserialize<'de> for GetHostCpuTopologyReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetHostCpuTopologyReply; + type Value = DialNetworkSocketRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.GetHostCpuTopologyReply") + formatter.write_str("struct protect.control.v1.DialNetworkSocketRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut cpus__ = None; + let mut request__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Cpus => { - if cpus__.is_some() { - return Err(serde::de::Error::duplicate_field("cpus")); + GeneratedField::Start => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("start")); } - cpus__ = Some(map_.next_value()?); + request__ = map_.next_value::<::std::option::Option<_>>()?.map(dial_network_socket_request::Request::Start) +; + } + GeneratedField::Data => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("data")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(dial_network_socket_request::Request::Data) +; } } } - Ok(GetHostCpuTopologyReply { - cpus: cpus__.unwrap_or_default(), + Ok(DialNetworkSocketRequest { + request: request__, }) } } - deserializer.deserialize_struct("protect.control.v1.GetHostCpuTopologyReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DialNetworkSocketRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetHostCpuTopologyRequest { +impl serde::Serialize for DialNetworkSocketStart { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.GetHostCpuTopologyRequest", len)?; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if !self.address.is_empty() { + len += 1; + } + if self.port != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialNetworkSocketStart", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.address.is_empty() { + struct_ser.serialize_field("address", &self.address)?; + } + if self.port != 0 { + struct_ser.serialize_field("port", &self.port)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetHostCpuTopologyRequest { +impl<'de> serde::Deserialize<'de> for DialNetworkSocketStart { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "address", + "port", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + ZoneId, + Address, + Port, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3175,7 +3092,12 @@ impl<'de> serde::Deserialize<'de> for GetHostCpuTopologyRequest { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "address" => Ok(GeneratedField::Address), + "port" => Ok(GeneratedField::Port), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -3183,27 +3105,54 @@ impl<'de> serde::Deserialize<'de> for GetHostCpuTopologyRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetHostCpuTopologyRequest; + type Value = DialNetworkSocketStart; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.GetHostCpuTopologyRequest") + formatter.write_str("struct protect.control.v1.DialNetworkSocketStart") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut zone_id__ = None; + let mut address__ = None; + let mut port__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Address => { + if address__.is_some() { + return Err(serde::de::Error::duplicate_field("address")); + } + address__ = Some(map_.next_value()?); + } + GeneratedField::Port => { + if port__.is_some() { + return Err(serde::de::Error::duplicate_field("port")); + } + port__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } } - Ok(GetHostCpuTopologyRequest { + Ok(DialNetworkSocketStart { + zone_id: zone_id__.unwrap_or_default(), + address: address__.unwrap_or_default(), + port: port__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.GetHostCpuTopologyRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DialNetworkSocketStart", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetHostStatusReply { +impl serde::Serialize for DialObjectCapabilityData { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3211,124 +3160,31 @@ impl serde::Serialize for GetHostStatusReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.host_uuid.is_empty() { - len += 1; - } - if self.host_domid != 0 { - len += 1; - } - if !self.protect_version.is_empty() { - len += 1; - } - if !self.host_ipv4.is_empty() { - len += 1; - } - if !self.host_ipv6.is_empty() { - len += 1; - } - if !self.host_mac.is_empty() { - len += 1; - } - 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() { + if !self.content.is_empty() { 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)?; - } - if self.host_domid != 0 { - struct_ser.serialize_field("hostDomid", &self.host_domid)?; - } - if !self.protect_version.is_empty() { - struct_ser.serialize_field("protectVersion", &self.protect_version)?; - } - if !self.host_ipv4.is_empty() { - struct_ser.serialize_field("hostIpv4", &self.host_ipv4)?; - } - if !self.host_ipv6.is_empty() { - struct_ser.serialize_field("hostIpv6", &self.host_ipv6)?; - } - if !self.host_mac.is_empty() { - struct_ser.serialize_field("hostMac", &self.host_mac)?; - } - if let Some(v) = self.hyp_free_mem.as_ref() { - #[allow(clippy::needless_borrow)] - #[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() { + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialObjectCapabilityData", len)?; + if !self.content.is_empty() { #[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.serialize_field("content", pbjson::private::base64::encode(&self.content).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetHostStatusReply { +impl<'de> serde::Deserialize<'de> for DialObjectCapabilityData { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "host_uuid", - "hostUuid", - "host_domid", - "hostDomid", - "protect_version", - "protectVersion", - "host_ipv4", - "hostIpv4", - "host_ipv6", - "hostIpv6", - "host_mac", - "hostMac", - "hyp_free_mem", - "hypFreeMem", - "protect_git_sha", - "protectGitSha", - "protect_last_tag", - "protectLastTag", - "protect_revs_since_tag", - "protectRevsSinceTag", - "protect_branch", - "protectBranch", + "content", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - HostUuid, - HostDomid, - ProtectVersion, - HostIpv4, - HostIpv6, - HostMac, - HypFreeMem, - ProtectGitSha, - ProtectLastTag, - ProtectRevsSinceTag, - ProtectBranch, + Content, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3350,17 +3206,7 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusReply { E: serde::de::Error, { match value { - "hostUuid" | "host_uuid" => Ok(GeneratedField::HostUuid), - "hostDomid" | "host_domid" => Ok(GeneratedField::HostDomid), - "protectVersion" | "protect_version" => Ok(GeneratedField::ProtectVersion), - "hostIpv4" | "host_ipv4" => Ok(GeneratedField::HostIpv4), - "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), + "content" => Ok(GeneratedField::Content), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3370,144 +3216,68 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetHostStatusReply; + type Value = DialObjectCapabilityData; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.GetHostStatusReply") + formatter.write_str("struct protect.control.v1.DialObjectCapabilityData") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut host_uuid__ = None; - let mut host_domid__ = None; - let mut protect_version__ = None; - let mut host_ipv4__ = None; - 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; + let mut content__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::HostUuid => { - if host_uuid__.is_some() { - return Err(serde::de::Error::duplicate_field("hostUuid")); - } - host_uuid__ = Some(map_.next_value()?); - } - GeneratedField::HostDomid => { - if host_domid__.is_some() { - return Err(serde::de::Error::duplicate_field("hostDomid")); + GeneratedField::Content => { + if content__.is_some() { + return Err(serde::de::Error::duplicate_field("content")); } - host_domid__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + content__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } - GeneratedField::ProtectVersion => { - if protect_version__.is_some() { - return Err(serde::de::Error::duplicate_field("protectVersion")); - } - protect_version__ = Some(map_.next_value()?); - } - GeneratedField::HostIpv4 => { - if host_ipv4__.is_some() { - return Err(serde::de::Error::duplicate_field("hostIpv4")); - } - host_ipv4__ = Some(map_.next_value()?); - } - GeneratedField::HostIpv6 => { - if host_ipv6__.is_some() { - return Err(serde::de::Error::duplicate_field("hostIpv6")); - } - host_ipv6__ = Some(map_.next_value()?); - } - GeneratedField::HostMac => { - if host_mac__.is_some() { - return Err(serde::de::Error::duplicate_field("hostMac")); - } - host_mac__ = Some(map_.next_value()?); - } - GeneratedField::HypFreeMem => { - if hyp_free_mem__.is_some() { - return Err(serde::de::Error::duplicate_field("hypFreeMem")); - } - hyp_free_mem__ = - 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 { - host_uuid: host_uuid__.unwrap_or_default(), - host_domid: host_domid__.unwrap_or_default(), - protect_version: protect_version__.unwrap_or_default(), - host_ipv4: host_ipv4__.unwrap_or_default(), - 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__, + Ok(DialObjectCapabilityData { + content: content__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.GetHostStatusReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DialObjectCapabilityData", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetHostStatusRequest { +impl serde::Serialize for DialObjectCapabilityReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.GetHostStatusRequest", len)?; + let mut len = 0; + if self.data.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialObjectCapabilityReply", len)?; + if let Some(v) = self.data.as_ref() { + struct_ser.serialize_field("data", v)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetHostStatusRequest { +impl<'de> serde::Deserialize<'de> for DialObjectCapabilityReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "data", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Data, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3528,7 +3298,10 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusRequest { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "data" => Ok(GeneratedField::Data), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -3536,27 +3309,36 @@ impl<'de> serde::Deserialize<'de> for GetHostStatusRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetHostStatusRequest; + type Value = DialObjectCapabilityReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.GetHostStatusRequest") + formatter.write_str("struct protect.control.v1.DialObjectCapabilityReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut data__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Data => { + if data__.is_some() { + return Err(serde::de::Error::duplicate_field("data")); + } + data__ = map_.next_value()?; + } + } } - Ok(GetHostStatusRequest { + Ok(DialObjectCapabilityReply { + data: data__, }) } } - deserializer.deserialize_struct("protect.control.v1.GetHostStatusRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DialObjectCapabilityReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetWorkloadReply { +impl serde::Serialize for DialObjectCapabilityRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3564,29 +3346,38 @@ impl serde::Serialize for GetWorkloadReply { { use serde::ser::SerializeStruct; let mut len = 0; - if self.workload.is_some() { + if self.request.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetWorkloadReply", len)?; - if let Some(v) = self.workload.as_ref() { - struct_ser.serialize_field("workload", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialObjectCapabilityRequest", len)?; + if let Some(v) = self.request.as_ref() { + match v { + dial_object_capability_request::Request::Start(v) => { + struct_ser.serialize_field("start", v)?; + } + dial_object_capability_request::Request::Data(v) => { + struct_ser.serialize_field("data", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetWorkloadReply { +impl<'de> serde::Deserialize<'de> for DialObjectCapabilityRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload", + "start", + "data", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Workload, + Start, + Data, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3608,7 +3399,8 @@ impl<'de> serde::Deserialize<'de> for GetWorkloadReply { E: serde::de::Error, { match value { - "workload" => Ok(GeneratedField::Workload), + "start" => Ok(GeneratedField::Start), + "data" => Ok(GeneratedField::Data), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3618,36 +3410,44 @@ impl<'de> serde::Deserialize<'de> for GetWorkloadReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetWorkloadReply; + type Value = DialObjectCapabilityRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.GetWorkloadReply") + formatter.write_str("struct protect.control.v1.DialObjectCapabilityRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload__ = None; + let mut request__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Workload => { - if workload__.is_some() { - return Err(serde::de::Error::duplicate_field("workload")); + GeneratedField::Start => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("start")); } - workload__ = map_.next_value()?; + request__ = map_.next_value::<::std::option::Option<_>>()?.map(dial_object_capability_request::Request::Start) +; + } + GeneratedField::Data => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("data")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(dial_object_capability_request::Request::Data) +; } } } - Ok(GetWorkloadReply { - workload: workload__, + Ok(DialObjectCapabilityRequest { + request: request__, }) } } - deserializer.deserialize_struct("protect.control.v1.GetWorkloadReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DialObjectCapabilityRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetWorkloadRequest { +impl serde::Serialize for DialObjectCapabilityStart { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3655,30 +3455,46 @@ impl serde::Serialize for GetWorkloadRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.workload_id.is_empty() { + if !self.name.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetWorkloadRequest", len)?; - if !self.workload_id.is_empty() { - struct_ser.serialize_field("workloadId", &self.workload_id)?; + if !self.caller_workload_id.is_empty() { + len += 1; + } + if !self.provider.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DialObjectCapabilityStart", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if !self.caller_workload_id.is_empty() { + struct_ser.serialize_field("callerWorkloadId", &self.caller_workload_id)?; + } + if !self.provider.is_empty() { + struct_ser.serialize_field("provider", &self.provider)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetWorkloadRequest { +impl<'de> serde::Deserialize<'de> for DialObjectCapabilityStart { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload_id", - "workloadId", + "name", + "caller_workload_id", + "callerWorkloadId", + "provider", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WorkloadId, + Name, + CallerWorkloadId, + Provider, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3700,7 +3516,9 @@ impl<'de> serde::Deserialize<'de> for GetWorkloadRequest { E: serde::de::Error, { match value { - "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "name" => Ok(GeneratedField::Name), + "callerWorkloadId" | "caller_workload_id" => Ok(GeneratedField::CallerWorkloadId), + "provider" => Ok(GeneratedField::Provider), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3710,36 +3528,52 @@ impl<'de> serde::Deserialize<'de> for GetWorkloadRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetWorkloadRequest; + type Value = DialObjectCapabilityStart; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.GetWorkloadRequest") + formatter.write_str("struct protect.control.v1.DialObjectCapabilityStart") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload_id__ = None; + let mut name__ = None; + let mut caller_workload_id__ = None; + let mut provider__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::WorkloadId => { - if workload_id__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadId")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - workload_id__ = Some(map_.next_value()?); + name__ = Some(map_.next_value()?); + } + GeneratedField::CallerWorkloadId => { + if caller_workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("callerWorkloadId")); + } + caller_workload_id__ = Some(map_.next_value()?); + } + GeneratedField::Provider => { + if provider__.is_some() { + return Err(serde::de::Error::duplicate_field("provider")); + } + provider__ = Some(map_.next_value()?); } } } - Ok(GetWorkloadRequest { - workload_id: workload_id__.unwrap_or_default(), + Ok(DialObjectCapabilityStart { + name: name__.unwrap_or_default(), + caller_workload_id: caller_workload_id__.unwrap_or_default(), + provider: provider__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.GetWorkloadRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DialObjectCapabilityStart", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetZoneReply { +impl serde::Serialize for DiscoverServicesReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3747,29 +3581,30 @@ impl serde::Serialize for GetZoneReply { { use serde::ser::SerializeStruct; let mut len = 0; - if self.zone.is_some() { + if !self.service_entry.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetZoneReply", len)?; - if let Some(v) = self.zone.as_ref() { - struct_ser.serialize_field("zone", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.DiscoverServicesReply", len)?; + if !self.service_entry.is_empty() { + struct_ser.serialize_field("serviceEntry", &self.service_entry)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetZoneReply { +impl<'de> serde::Deserialize<'de> for DiscoverServicesReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone", + "service_entry", + "serviceEntry", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Zone, + ServiceEntry, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3791,7 +3626,7 @@ impl<'de> serde::Deserialize<'de> for GetZoneReply { E: serde::de::Error, { match value { - "zone" => Ok(GeneratedField::Zone), + "serviceEntry" | "service_entry" => Ok(GeneratedField::ServiceEntry), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3801,67 +3636,58 @@ impl<'de> serde::Deserialize<'de> for GetZoneReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetZoneReply; + type Value = DiscoverServicesReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.GetZoneReply") + formatter.write_str("struct protect.control.v1.DiscoverServicesReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone__ = None; + let mut service_entry__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Zone => { - if zone__.is_some() { - return Err(serde::de::Error::duplicate_field("zone")); + GeneratedField::ServiceEntry => { + if service_entry__.is_some() { + return Err(serde::de::Error::duplicate_field("serviceEntry")); } - zone__ = map_.next_value()?; + service_entry__ = Some(map_.next_value()?); } } } - Ok(GetZoneReply { - zone: zone__, + Ok(DiscoverServicesReply { + service_entry: service_entry__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.GetZoneReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DiscoverServicesReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetZoneRequest { +impl serde::Serialize for DiscoverServicesRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.zone_id.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetZoneRequest", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.DiscoverServicesRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetZoneRequest { +impl<'de> serde::Deserialize<'de> for DiscoverServicesRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3882,10 +3708,7 @@ impl<'de> serde::Deserialize<'de> for GetZoneRequest { where E: serde::de::Error, { - match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -3893,110 +3716,135 @@ impl<'de> serde::Deserialize<'de> for GetZoneRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetZoneRequest; + type Value = DiscoverServicesRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.GetZoneRequest") + formatter.write_str("struct protect.control.v1.DiscoverServicesRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); - } - zone_id__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(GetZoneRequest { - zone_id: zone_id__.unwrap_or_default(), + Ok(DiscoverServicesRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.GetZoneRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.DiscoverServicesRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for HostCpuTopologyClass { +impl serde::Serialize for EnvironmentVariableSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Standard => "HOST_CPU_TOPOLOGY_CLASS_STANDARD", - Self::Performance => "HOST_CPU_TOPOLOGY_CLASS_PERFORMANCE", - Self::Efficiency => "HOST_CPU_TOPOLOGY_CLASS_EFFICIENCY", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key.is_empty() { + len += 1; + } + if !self.value.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.EnvironmentVariableSpec", len)?; + if !self.key.is_empty() { + struct_ser.serialize_field("key", &self.key)?; + } + if !self.value.is_empty() { + struct_ser.serialize_field("value", &self.value)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for HostCpuTopologyClass { +impl<'de> serde::Deserialize<'de> for EnvironmentVariableSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "HOST_CPU_TOPOLOGY_CLASS_STANDARD", - "HOST_CPU_TOPOLOGY_CLASS_PERFORMANCE", - "HOST_CPU_TOPOLOGY_CLASS_EFFICIENCY", - ]; + "key", + "value", + ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Key, + Value, + } + 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 = HostCpuTopologyClass; + 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) - } + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "key" => Ok(GeneratedField::Key), + "value" => Ok(GeneratedField::Value), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EnvironmentVariableSpec; - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.EnvironmentVariableSpec") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "HOST_CPU_TOPOLOGY_CLASS_STANDARD" => Ok(HostCpuTopologyClass::Standard), - "HOST_CPU_TOPOLOGY_CLASS_PERFORMANCE" => Ok(HostCpuTopologyClass::Performance), - "HOST_CPU_TOPOLOGY_CLASS_EFFICIENCY" => Ok(HostCpuTopologyClass::Efficiency), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut key__ = None; + let mut value__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); + } + key__ = Some(map_.next_value()?); + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = Some(map_.next_value()?); + } + } } + Ok(EnvironmentVariableSpec { + key: key__.unwrap_or_default(), + value: value__.unwrap_or_default(), + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.EnvironmentVariableSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for HostCpuTopologyInfo { +impl serde::Serialize for ExecuteZoneCommandExited { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4004,63 +3852,30 @@ impl serde::Serialize for HostCpuTopologyInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if self.core != 0 { - len += 1; - } - if self.socket != 0 { - len += 1; - } - if self.node != 0 { - len += 1; - } - if self.thread != 0 { - len += 1; - } - if self.class != 0 { + if self.exit_code != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.HostCpuTopologyInfo", len)?; - if self.core != 0 { - struct_ser.serialize_field("core", &self.core)?; - } - if self.socket != 0 { - struct_ser.serialize_field("socket", &self.socket)?; - } - if self.node != 0 { - struct_ser.serialize_field("node", &self.node)?; - } - if self.thread != 0 { - struct_ser.serialize_field("thread", &self.thread)?; - } - if self.class != 0 { - let v = HostCpuTopologyClass::try_from(self.class) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.class)))?; - struct_ser.serialize_field("class", &v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandExited", len)?; + if self.exit_code != 0 { + struct_ser.serialize_field("exitCode", &self.exit_code)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for HostCpuTopologyInfo { +impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandExited { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "core", - "socket", - "node", - "thread", - "class", + "exit_code", + "exitCode", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Core, - Socket, - Node, - Thread, - Class, + ExitCode, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4082,11 +3897,7 @@ impl<'de> serde::Deserialize<'de> for HostCpuTopologyInfo { E: serde::de::Error, { match value { - "core" => Ok(GeneratedField::Core), - "socket" => Ok(GeneratedField::Socket), - "node" => Ok(GeneratedField::Node), - "thread" => Ok(GeneratedField::Thread), - "class" => Ok(GeneratedField::Class), + "exitCode" | "exit_code" => Ok(GeneratedField::ExitCode), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4096,76 +3907,38 @@ impl<'de> serde::Deserialize<'de> for HostCpuTopologyInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = HostCpuTopologyInfo; + type Value = ExecuteZoneCommandExited; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.HostCpuTopologyInfo") + formatter.write_str("struct protect.control.v1.ExecuteZoneCommandExited") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut core__ = None; - let mut socket__ = None; - let mut node__ = None; - let mut thread__ = None; - let mut class__ = None; + let mut exit_code__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Core => { - if core__.is_some() { - return Err(serde::de::Error::duplicate_field("core")); - } - core__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Socket => { - if socket__.is_some() { - return Err(serde::de::Error::duplicate_field("socket")); - } - socket__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Node => { - if node__.is_some() { - return Err(serde::de::Error::duplicate_field("node")); - } - node__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Thread => { - if thread__.is_some() { - return Err(serde::de::Error::duplicate_field("thread")); + GeneratedField::ExitCode => { + if exit_code__.is_some() { + return Err(serde::de::Error::duplicate_field("exitCode")); } - thread__ = + exit_code__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Class => { - if class__.is_some() { - return Err(serde::de::Error::duplicate_field("class")); - } - class__ = Some(map_.next_value::()? as i32); - } } } - Ok(HostCpuTopologyInfo { - core: core__.unwrap_or_default(), - socket: socket__.unwrap_or_default(), - node: node__.unwrap_or_default(), - thread: thread__.unwrap_or_default(), - class: class__.unwrap_or_default(), + Ok(ExecuteZoneCommandExited { + exit_code: exit_code__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.HostCpuTopologyInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandExited", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for HypervisorDebugInfoReply { +impl serde::Serialize for ExecuteZoneCommandOutput { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4173,29 +3946,41 @@ impl serde::Serialize for HypervisorDebugInfoReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.json.is_empty() { + if !self.stdout.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.HypervisorDebugInfoReply", len)?; - if !self.json.is_empty() { - struct_ser.serialize_field("json", &self.json)?; + if !self.stderr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandOutput", len)?; + if !self.stdout.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("stdout", pbjson::private::base64::encode(&self.stdout).as_str())?; + } + if !self.stderr.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("stderr", pbjson::private::base64::encode(&self.stderr).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for HypervisorDebugInfoReply { +impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandOutput { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "json", + "stdout", + "stderr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Json, + Stdout, + Stderr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4217,7 +4002,8 @@ impl<'de> serde::Deserialize<'de> for HypervisorDebugInfoReply { E: serde::de::Error, { match value { - "json" => Ok(GeneratedField::Json), + "stdout" => Ok(GeneratedField::Stdout), + "stderr" => Ok(GeneratedField::Stderr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4227,58 +4013,87 @@ impl<'de> serde::Deserialize<'de> for HypervisorDebugInfoReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = HypervisorDebugInfoReply; + type Value = ExecuteZoneCommandOutput; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.HypervisorDebugInfoReply") + formatter.write_str("struct protect.control.v1.ExecuteZoneCommandOutput") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut json__ = None; + let mut stdout__ = None; + let mut stderr__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Json => { - if json__.is_some() { - return Err(serde::de::Error::duplicate_field("json")); + GeneratedField::Stdout => { + if stdout__.is_some() { + return Err(serde::de::Error::duplicate_field("stdout")); } - json__ = Some(map_.next_value()?); + stdout__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Stderr => { + if stderr__.is_some() { + return Err(serde::de::Error::duplicate_field("stderr")); + } + stderr__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; } } } - Ok(HypervisorDebugInfoReply { - json: json__.unwrap_or_default(), + Ok(ExecuteZoneCommandOutput { + stdout: stdout__.unwrap_or_default(), + stderr: stderr__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.HypervisorDebugInfoReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandOutput", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for HypervisorDebugInfoRequest { +impl serde::Serialize for ExecuteZoneCommandReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.HypervisorDebugInfoRequest", len)?; + let mut len = 0; + if self.reply.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandReply", len)?; + if let Some(v) = self.reply.as_ref() { + match v { + execute_zone_command_reply::Reply::Output(v) => { + struct_ser.serialize_field("output", v)?; + } + execute_zone_command_reply::Reply::Exited(v) => { + struct_ser.serialize_field("exited", v)?; + } + } + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for HypervisorDebugInfoRequest { +impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "output", + "exited", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Output, + Exited, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4299,7 +4114,11 @@ impl<'de> serde::Deserialize<'de> for HypervisorDebugInfoRequest { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "output" => Ok(GeneratedField::Output), + "exited" => Ok(GeneratedField::Exited), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -4307,27 +4126,44 @@ impl<'de> serde::Deserialize<'de> for HypervisorDebugInfoRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = HypervisorDebugInfoRequest; + type Value = ExecuteZoneCommandReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.HypervisorDebugInfoRequest") + formatter.write_str("struct protect.control.v1.ExecuteZoneCommandReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut reply__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Output => { + if reply__.is_some() { + return Err(serde::de::Error::duplicate_field("output")); + } + reply__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_reply::Reply::Output) +; + } + GeneratedField::Exited => { + if reply__.is_some() { + return Err(serde::de::Error::duplicate_field("exited")); + } + reply__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_reply::Reply::Exited) +; + } + } } - Ok(HypervisorDebugInfoRequest { + Ok(ExecuteZoneCommandReply { + reply: reply__, }) } } - deserializer.deserialize_struct("protect.control.v1.HypervisorDebugInfoRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IdOrNameValue { +impl serde::Serialize for ExecuteZoneCommandRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4335,38 +4171,44 @@ impl serde::Serialize for IdOrNameValue { { use serde::ser::SerializeStruct; let mut len = 0; - if self.id_or_name.is_some() { + if self.request.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.IdOrNameValue", len)?; - if let Some(v) = self.id_or_name.as_ref() { + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandRequest", len)?; + if let Some(v) = self.request.as_ref() { match v { - id_or_name_value::IdOrName::Id(v) => { - struct_ser.serialize_field("id", v)?; + execute_zone_command_request::Request::Start(v) => { + struct_ser.serialize_field("start", v)?; } - id_or_name_value::IdOrName::Name(v) => { - struct_ser.serialize_field("name", v)?; + execute_zone_command_request::Request::Stdin(v) => { + struct_ser.serialize_field("stdin", v)?; + } + execute_zone_command_request::Request::TerminalResize(v) => { + struct_ser.serialize_field("terminalResize", v)?; } } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IdOrNameValue { +impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "id", - "name", + "start", + "stdin", + "terminal_resize", + "terminalResize", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Id, - Name, + Start, + Stdin, + TerminalResize, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4388,8 +4230,9 @@ impl<'de> serde::Deserialize<'de> for IdOrNameValue { E: serde::de::Error, { match value { - "id" => Ok(GeneratedField::Id), - "name" => Ok(GeneratedField::Name), + "start" => Ok(GeneratedField::Start), + "stdin" => Ok(GeneratedField::Stdin), + "terminalResize" | "terminal_resize" => Ok(GeneratedField::TerminalResize), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4399,42 +4242,51 @@ impl<'de> serde::Deserialize<'de> for IdOrNameValue { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IdOrNameValue; + type Value = ExecuteZoneCommandRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.IdOrNameValue") + formatter.write_str("struct protect.control.v1.ExecuteZoneCommandRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut id_or_name__ = None; + let mut request__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Id => { - if id_or_name__.is_some() { - return Err(serde::de::Error::duplicate_field("id")); + GeneratedField::Start => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("start")); } - id_or_name__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| id_or_name_value::IdOrName::Id(x.0)); + request__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_request::Request::Start) +; } - GeneratedField::Name => { - if id_or_name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); + GeneratedField::Stdin => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("stdin")); } - id_or_name__ = map_.next_value::<::std::option::Option<_>>()?.map(id_or_name_value::IdOrName::Name); + request__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_request::Request::Stdin) +; + } + GeneratedField::TerminalResize => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("terminalResize")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(execute_zone_command_request::Request::TerminalResize) +; } } } - Ok(IdOrNameValue { - id_or_name: id_or_name__, + Ok(ExecuteZoneCommandRequest { + request: request__, }) } } - deserializer.deserialize_struct("protect.control.v1.IdOrNameValue", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ImportImageReply { +impl serde::Serialize for ExecuteZoneCommandStart { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4442,53 +4294,47 @@ impl serde::Serialize for ImportImageReply { { use serde::ser::SerializeStruct; let mut len = 0; - if self.accepted { - len += 1; - } - if self.progress.is_some() { + if !self.zone_id.is_empty() { len += 1; } - if self.spec.is_some() { + if !self.workload_id.is_empty() { len += 1; } - if self.metadata.is_some() { + if self.process.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ImportImageReply", len)?; - if self.accepted { - struct_ser.serialize_field("accepted", &self.accepted)?; - } - if let Some(v) = self.progress.as_ref() { - struct_ser.serialize_field("progress", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandStart", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } - if let Some(v) = self.spec.as_ref() { - struct_ser.serialize_field("spec", v)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; } - if let Some(v) = self.metadata.as_ref() { - struct_ser.serialize_field("metadata", v)?; + if let Some(v) = self.process.as_ref() { + struct_ser.serialize_field("process", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ImportImageReply { +impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandStart { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "accepted", - "progress", - "spec", - "metadata", + "zone_id", + "zoneId", + "workload_id", + "workloadId", + "process", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Accepted, - Progress, - Spec, - Metadata, + ZoneId, + WorkloadId, + Process, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4510,10 +4356,9 @@ impl<'de> serde::Deserialize<'de> for ImportImageReply { E: serde::de::Error, { match value { - "accepted" => Ok(GeneratedField::Accepted), - "progress" => Ok(GeneratedField::Progress), - "spec" => Ok(GeneratedField::Spec), - "metadata" => Ok(GeneratedField::Metadata), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "process" => Ok(GeneratedField::Process), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4523,60 +4368,52 @@ impl<'de> serde::Deserialize<'de> for ImportImageReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ImportImageReply; + type Value = ExecuteZoneCommandStart; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ImportImageReply") + formatter.write_str("struct protect.control.v1.ExecuteZoneCommandStart") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut accepted__ = None; - let mut progress__ = None; - let mut spec__ = None; - let mut metadata__ = None; + let mut zone_id__ = None; + let mut workload_id__ = None; + let mut process__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Accepted => { - if accepted__.is_some() { - return Err(serde::de::Error::duplicate_field("accepted")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - accepted__ = Some(map_.next_value()?); + zone_id__ = Some(map_.next_value()?); } - GeneratedField::Progress => { - if progress__.is_some() { - return Err(serde::de::Error::duplicate_field("progress")); + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); } - progress__ = map_.next_value()?; + workload_id__ = Some(map_.next_value()?); } - GeneratedField::Spec => { - if spec__.is_some() { - return Err(serde::de::Error::duplicate_field("spec")); + GeneratedField::Process => { + if process__.is_some() { + return Err(serde::de::Error::duplicate_field("process")); } - spec__ = map_.next_value()?; - } - GeneratedField::Metadata => { - if metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("metadata")); - } - metadata__ = map_.next_value()?; + process__ = map_.next_value()?; } } } - Ok(ImportImageReply { - accepted: accepted__.unwrap_or_default(), - progress: progress__, - spec: spec__, - metadata: metadata__, + Ok(ExecuteZoneCommandStart { + zone_id: zone_id__.unwrap_or_default(), + workload_id: workload_id__.unwrap_or_default(), + process: process__, }) } } - deserializer.deserialize_struct("protect.control.v1.ImportImageReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandStart", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ImportImageRequest { +impl serde::Serialize for ExecuteZoneCommandStdin { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4584,84 +4421,39 @@ impl serde::Serialize for ImportImageRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.digest.is_empty() { - len += 1; - } - if !self.image.is_empty() { - len += 1; - } - if self.format != 0 { - len += 1; - } - if !self.chunk.is_empty() { - len += 1; - } - if self.last_chunk { - len += 1; - } - if self.overwrite_cache { + if !self.stdin.is_empty() { len += 1; } - if self.want_metadata { + if self.closed { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ImportImageRequest", len)?; - if !self.digest.is_empty() { - struct_ser.serialize_field("digest", &self.digest)?; - } - if !self.image.is_empty() { - struct_ser.serialize_field("image", &self.image)?; - } - if self.format != 0 { - let v = OciImageFormat::try_from(self.format) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; - struct_ser.serialize_field("format", &v)?; - } - if !self.chunk.is_empty() { + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandStdin", len)?; + if !self.stdin.is_empty() { #[allow(clippy::needless_borrow)] #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("chunk", pbjson::private::base64::encode(&self.chunk).as_str())?; - } - if self.last_chunk { - struct_ser.serialize_field("lastChunk", &self.last_chunk)?; - } - if self.overwrite_cache { - struct_ser.serialize_field("overwriteCache", &self.overwrite_cache)?; + struct_ser.serialize_field("stdin", pbjson::private::base64::encode(&self.stdin).as_str())?; } - if self.want_metadata { - struct_ser.serialize_field("wantMetadata", &self.want_metadata)?; + if self.closed { + struct_ser.serialize_field("closed", &self.closed)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ImportImageRequest { +impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandStdin { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "digest", - "image", - "format", - "chunk", - "last_chunk", - "lastChunk", - "overwrite_cache", - "overwriteCache", - "want_metadata", - "wantMetadata", + "stdin", + "closed", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Digest, - Image, - Format, - Chunk, - LastChunk, - OverwriteCache, - WantMetadata, + Stdin, + Closed, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4683,13 +4475,8 @@ impl<'de> serde::Deserialize<'de> for ImportImageRequest { E: serde::de::Error, { match value { - "digest" => Ok(GeneratedField::Digest), - "image" => Ok(GeneratedField::Image), - "format" => Ok(GeneratedField::Format), - "chunk" => Ok(GeneratedField::Chunk), - "lastChunk" | "last_chunk" => Ok(GeneratedField::LastChunk), - "overwriteCache" | "overwrite_cache" => Ok(GeneratedField::OverwriteCache), - "wantMetadata" | "want_metadata" => Ok(GeneratedField::WantMetadata), + "stdin" => Ok(GeneratedField::Stdin), + "closed" => Ok(GeneratedField::Closed), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4699,86 +4486,46 @@ impl<'de> serde::Deserialize<'de> for ImportImageRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ImportImageRequest; + type Value = ExecuteZoneCommandStdin; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ImportImageRequest") + formatter.write_str("struct protect.control.v1.ExecuteZoneCommandStdin") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut digest__ = None; - let mut image__ = None; - let mut format__ = None; - let mut chunk__ = None; - let mut last_chunk__ = None; - let mut overwrite_cache__ = None; - let mut want_metadata__ = None; + let mut stdin__ = None; + let mut closed__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Digest => { - if digest__.is_some() { - return Err(serde::de::Error::duplicate_field("digest")); - } - digest__ = Some(map_.next_value()?); - } - GeneratedField::Image => { - if image__.is_some() { - return Err(serde::de::Error::duplicate_field("image")); - } - image__ = Some(map_.next_value()?); - } - GeneratedField::Format => { - if format__.is_some() { - return Err(serde::de::Error::duplicate_field("format")); - } - format__ = Some(map_.next_value::()? as i32); - } - GeneratedField::Chunk => { - if chunk__.is_some() { - return Err(serde::de::Error::duplicate_field("chunk")); + GeneratedField::Stdin => { + if stdin__.is_some() { + return Err(serde::de::Error::duplicate_field("stdin")); } - chunk__ = + stdin__ = Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } - GeneratedField::LastChunk => { - if last_chunk__.is_some() { - return Err(serde::de::Error::duplicate_field("lastChunk")); - } - last_chunk__ = Some(map_.next_value()?); - } - GeneratedField::OverwriteCache => { - if overwrite_cache__.is_some() { - return Err(serde::de::Error::duplicate_field("overwriteCache")); - } - overwrite_cache__ = Some(map_.next_value()?); - } - GeneratedField::WantMetadata => { - if want_metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("wantMetadata")); + GeneratedField::Closed => { + if closed__.is_some() { + return Err(serde::de::Error::duplicate_field("closed")); } - want_metadata__ = Some(map_.next_value()?); + closed__ = Some(map_.next_value()?); } } } - Ok(ImportImageRequest { - digest: digest__.unwrap_or_default(), - image: image__.unwrap_or_default(), - format: format__.unwrap_or_default(), - chunk: chunk__.unwrap_or_default(), - last_chunk: last_chunk__.unwrap_or_default(), - overwrite_cache: overwrite_cache__.unwrap_or_default(), - want_metadata: want_metadata__.unwrap_or_default(), + Ok(ExecuteZoneCommandStdin { + stdin: stdin__.unwrap_or_default(), + closed: closed__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ImportImageRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandStdin", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for KernelModuleParameter { +impl serde::Serialize for ExecuteZoneCommandTerminalResize { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4786,37 +4533,29 @@ impl serde::Serialize for KernelModuleParameter { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.module.is_empty() { - len += 1; - } - if !self.parameter.is_empty() { + if self.size.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.KernelModuleParameter", len)?; - if !self.module.is_empty() { - struct_ser.serialize_field("module", &self.module)?; - } - if !self.parameter.is_empty() { - struct_ser.serialize_field("parameter", &self.parameter)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExecuteZoneCommandTerminalResize", len)?; + if let Some(v) = self.size.as_ref() { + struct_ser.serialize_field("size", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for KernelModuleParameter { +impl<'de> serde::Deserialize<'de> for ExecuteZoneCommandTerminalResize { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "module", - "parameter", + "size", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Module, - Parameter, + Size, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4838,8 +4577,7 @@ impl<'de> serde::Deserialize<'de> for KernelModuleParameter { E: serde::de::Error, { match value { - "module" => Ok(GeneratedField::Module), - "parameter" => Ok(GeneratedField::Parameter), + "size" => Ok(GeneratedField::Size), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4849,44 +4587,36 @@ impl<'de> serde::Deserialize<'de> for KernelModuleParameter { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = KernelModuleParameter; + type Value = ExecuteZoneCommandTerminalResize; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.KernelModuleParameter") + formatter.write_str("struct protect.control.v1.ExecuteZoneCommandTerminalResize") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut module__ = None; - let mut parameter__ = None; + let mut size__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Module => { - if module__.is_some() { - return Err(serde::de::Error::duplicate_field("module")); - } - module__ = Some(map_.next_value()?); - } - GeneratedField::Parameter => { - if parameter__.is_some() { - return Err(serde::de::Error::duplicate_field("parameter")); + GeneratedField::Size => { + if size__.is_some() { + return Err(serde::de::Error::duplicate_field("size")); } - parameter__ = Some(map_.next_value()?); + size__ = map_.next_value()?; } } } - Ok(KernelModuleParameter { - module: module__.unwrap_or_default(), - parameter: parameter__.unwrap_or_default(), + Ok(ExecuteZoneCommandTerminalResize { + size: size__, }) } } - deserializer.deserialize_struct("protect.control.v1.KernelModuleParameter", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExecuteZoneCommandTerminalResize", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for KernelOptionsSpec { +impl serde::Serialize for ExportZoneComplete { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4894,72 +4624,43 @@ impl serde::Serialize for KernelOptionsSpec { { use serde::ser::SerializeStruct; let mut len = 0; - if self.verbose { - len += 1; - } - if !self.cmdline_append.is_empty() { + if self.total_bytes != 0 { len += 1; } - if !self.cmdline.is_empty() { + if self.captured_mount_bytes != 0 { len += 1; } - if !self.modules.is_empty() { - len += 1; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExportZoneComplete", len)?; + if self.total_bytes != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("totalBytes", ToString::to_string(&self.total_bytes).as_str())?; } - if !self.module_parameters.is_empty() { - len += 1; + if self.captured_mount_bytes != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("capturedMountBytes", ToString::to_string(&self.captured_mount_bytes).as_str())?; } - if !self.sysctl_parameters.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.KernelOptionsSpec", len)?; - if self.verbose { - struct_ser.serialize_field("verbose", &self.verbose)?; - } - if !self.cmdline_append.is_empty() { - struct_ser.serialize_field("cmdlineAppend", &self.cmdline_append)?; - } - if !self.cmdline.is_empty() { - struct_ser.serialize_field("cmdline", &self.cmdline)?; - } - if !self.modules.is_empty() { - struct_ser.serialize_field("modules", &self.modules)?; - } - if !self.module_parameters.is_empty() { - struct_ser.serialize_field("moduleParameters", &self.module_parameters)?; - } - if !self.sysctl_parameters.is_empty() { - struct_ser.serialize_field("sysctlParameters", &self.sysctl_parameters)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for KernelOptionsSpec { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "verbose", - "cmdline_append", - "cmdlineAppend", - "cmdline", - "modules", - "module_parameters", - "moduleParameters", - "sysctl_parameters", - "sysctlParameters", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Verbose, - CmdlineAppend, - Cmdline, - Modules, - ModuleParameters, - SysctlParameters, + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ExportZoneComplete { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "total_bytes", + "totalBytes", + "captured_mount_bytes", + "capturedMountBytes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TotalBytes, + CapturedMountBytes, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4981,12 +4682,8 @@ impl<'de> serde::Deserialize<'de> for KernelOptionsSpec { E: serde::de::Error, { match value { - "verbose" => Ok(GeneratedField::Verbose), - "cmdlineAppend" | "cmdline_append" => Ok(GeneratedField::CmdlineAppend), - "cmdline" => Ok(GeneratedField::Cmdline), - "modules" => Ok(GeneratedField::Modules), - "moduleParameters" | "module_parameters" => Ok(GeneratedField::ModuleParameters), - "sysctlParameters" | "sysctl_parameters" => Ok(GeneratedField::SysctlParameters), + "totalBytes" | "total_bytes" => Ok(GeneratedField::TotalBytes), + "capturedMountBytes" | "captured_mount_bytes" => Ok(GeneratedField::CapturedMountBytes), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4996,76 +4693,48 @@ impl<'de> serde::Deserialize<'de> for KernelOptionsSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = KernelOptionsSpec; + type Value = ExportZoneComplete; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.KernelOptionsSpec") + formatter.write_str("struct protect.control.v1.ExportZoneComplete") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut verbose__ = None; - let mut cmdline_append__ = None; - let mut cmdline__ = None; - let mut modules__ = None; - let mut module_parameters__ = None; - let mut sysctl_parameters__ = None; + let mut total_bytes__ = None; + let mut captured_mount_bytes__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Verbose => { - if verbose__.is_some() { - return Err(serde::de::Error::duplicate_field("verbose")); + GeneratedField::TotalBytes => { + if total_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("totalBytes")); } - verbose__ = Some(map_.next_value()?); - } - GeneratedField::CmdlineAppend => { - if cmdline_append__.is_some() { - return Err(serde::de::Error::duplicate_field("cmdlineAppend")); - } - cmdline_append__ = Some(map_.next_value()?); - } - GeneratedField::Cmdline => { - if cmdline__.is_some() { - return Err(serde::de::Error::duplicate_field("cmdline")); - } - cmdline__ = Some(map_.next_value()?); - } - GeneratedField::Modules => { - if modules__.is_some() { - return Err(serde::de::Error::duplicate_field("modules")); - } - modules__ = Some(map_.next_value()?); - } - GeneratedField::ModuleParameters => { - if module_parameters__.is_some() { - return Err(serde::de::Error::duplicate_field("moduleParameters")); - } - module_parameters__ = Some(map_.next_value()?); + total_bytes__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::SysctlParameters => { - if sysctl_parameters__.is_some() { - return Err(serde::de::Error::duplicate_field("sysctlParameters")); + GeneratedField::CapturedMountBytes => { + if captured_mount_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("capturedMountBytes")); } - sysctl_parameters__ = Some(map_.next_value()?); + captured_mount_bytes__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(KernelOptionsSpec { - verbose: verbose__.unwrap_or_default(), - cmdline_append: cmdline_append__.unwrap_or_default(), - cmdline: cmdline__.unwrap_or_default(), - modules: modules__.unwrap_or_default(), - module_parameters: module_parameters__.unwrap_or_default(), - sysctl_parameters: sysctl_parameters__.unwrap_or_default(), + Ok(ExportZoneComplete { + total_bytes: total_bytes__.unwrap_or_default(), + captured_mount_bytes: captured_mount_bytes__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.KernelOptionsSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExportZoneComplete", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for KernelSysctlParameter { +impl serde::Serialize for ExportZoneReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5073,37 +4742,45 @@ impl serde::Serialize for KernelSysctlParameter { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.key.is_empty() { - len += 1; - } - if !self.value.is_empty() { + if self.reply.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.KernelSysctlParameter", len)?; - if !self.key.is_empty() { - struct_ser.serialize_field("key", &self.key)?; - } - if !self.value.is_empty() { - struct_ser.serialize_field("value", &self.value)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExportZoneReply", len)?; + if let Some(v) = self.reply.as_ref() { + match v { + export_zone_reply::Reply::Start(v) => { + struct_ser.serialize_field("start", v)?; + } + export_zone_reply::Reply::Chunk(v) => { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("chunk", pbjson::private::base64::encode(&v).as_str())?; + } + export_zone_reply::Reply::Complete(v) => { + struct_ser.serialize_field("complete", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for KernelSysctlParameter { +impl<'de> serde::Deserialize<'de> for ExportZoneReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "key", - "value", + "start", + "chunk", + "complete", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Key, - Value, + Start, + Chunk, + Complete, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5125,8 +4802,9 @@ impl<'de> serde::Deserialize<'de> for KernelSysctlParameter { E: serde::de::Error, { match value { - "key" => Ok(GeneratedField::Key), - "value" => Ok(GeneratedField::Value), + "start" => Ok(GeneratedField::Start), + "chunk" => Ok(GeneratedField::Chunk), + "complete" => Ok(GeneratedField::Complete), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5136,44 +4814,50 @@ impl<'de> serde::Deserialize<'de> for KernelSysctlParameter { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = KernelSysctlParameter; + type Value = ExportZoneReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.KernelSysctlParameter") + formatter.write_str("struct protect.control.v1.ExportZoneReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut key__ = None; - let mut value__ = None; + let mut reply__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Key => { - if key__.is_some() { - return Err(serde::de::Error::duplicate_field("key")); + GeneratedField::Start => { + if reply__.is_some() { + return Err(serde::de::Error::duplicate_field("start")); } - key__ = Some(map_.next_value()?); + reply__ = map_.next_value::<::std::option::Option<_>>()?.map(export_zone_reply::Reply::Start) +; } - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); + GeneratedField::Chunk => { + if reply__.is_some() { + return Err(serde::de::Error::duplicate_field("chunk")); } - value__ = Some(map_.next_value()?); + reply__ = map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| export_zone_reply::Reply::Chunk(x.0)); + } + GeneratedField::Complete => { + if reply__.is_some() { + return Err(serde::de::Error::duplicate_field("complete")); + } + reply__ = map_.next_value::<::std::option::Option<_>>()?.map(export_zone_reply::Reply::Complete) +; } } } - Ok(KernelSysctlParameter { - key: key__.unwrap_or_default(), - value: value__.unwrap_or_default(), + Ok(ExportZoneReply { + reply: reply__, }) } } - deserializer.deserialize_struct("protect.control.v1.KernelSysctlParameter", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExportZoneReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListDevicesReply { +impl serde::Serialize for ExportZoneRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5181,29 +4865,56 @@ impl serde::Serialize for ListDevicesReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.devices.is_empty() { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListDevicesReply", len)?; - if !self.devices.is_empty() { - struct_ser.serialize_field("devices", &self.devices)?; + if self.leave_suspended { + len += 1; + } + if self.compress { + len += 1; + } + if !self.capture_mounts.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExportZoneRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if self.leave_suspended { + struct_ser.serialize_field("leaveSuspended", &self.leave_suspended)?; + } + if self.compress { + struct_ser.serialize_field("compress", &self.compress)?; + } + if !self.capture_mounts.is_empty() { + struct_ser.serialize_field("captureMounts", &self.capture_mounts)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ListDevicesReply { +impl<'de> serde::Deserialize<'de> for ExportZoneRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "devices", + "zone_id", + "zoneId", + "leave_suspended", + "leaveSuspended", + "compress", + "capture_mounts", + "captureMounts", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Devices, + ZoneId, + LeaveSuspended, + Compress, + CaptureMounts, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5225,7 +4936,10 @@ impl<'de> serde::Deserialize<'de> for ListDevicesReply { E: serde::de::Error, { match value { - "devices" => Ok(GeneratedField::Devices), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "leaveSuspended" | "leave_suspended" => Ok(GeneratedField::LeaveSuspended), + "compress" => Ok(GeneratedField::Compress), + "captureMounts" | "capture_mounts" => Ok(GeneratedField::CaptureMounts), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5235,58 +4949,120 @@ impl<'de> serde::Deserialize<'de> for ListDevicesReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListDevicesReply; + type Value = ExportZoneRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListDevicesReply") + formatter.write_str("struct protect.control.v1.ExportZoneRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut devices__ = None; + let mut zone_id__ = None; + let mut leave_suspended__ = None; + let mut compress__ = None; + let mut capture_mounts__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Devices => { - if devices__.is_some() { - return Err(serde::de::Error::duplicate_field("devices")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - devices__ = Some(map_.next_value()?); + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::LeaveSuspended => { + if leave_suspended__.is_some() { + return Err(serde::de::Error::duplicate_field("leaveSuspended")); + } + leave_suspended__ = Some(map_.next_value()?); + } + GeneratedField::Compress => { + if compress__.is_some() { + return Err(serde::de::Error::duplicate_field("compress")); + } + compress__ = Some(map_.next_value()?); + } + GeneratedField::CaptureMounts => { + if capture_mounts__.is_some() { + return Err(serde::de::Error::duplicate_field("captureMounts")); + } + capture_mounts__ = Some(map_.next_value()?); } } } - Ok(ListDevicesReply { - devices: devices__.unwrap_or_default(), + Ok(ExportZoneRequest { + zone_id: zone_id__.unwrap_or_default(), + leave_suspended: leave_suspended__.unwrap_or_default(), + compress: compress__.unwrap_or_default(), + capture_mounts: capture_mounts__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ListDevicesReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExportZoneRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListDevicesRequest { +impl serde::Serialize for ExportZoneStart { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.ListDevicesRequest", len)?; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if self.backend != 0 { + len += 1; + } + if self.arch != 0 { + len += 1; + } + if self.format_version != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ExportZoneStart", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if self.backend != 0 { + let v = ZoneSnapshotBackend::try_from(self.backend) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backend)))?; + struct_ser.serialize_field("backend", &v)?; + } + if self.arch != 0 { + let v = ZoneSnapshotArch::try_from(self.arch) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.arch)))?; + struct_ser.serialize_field("arch", &v)?; + } + if self.format_version != 0 { + struct_ser.serialize_field("formatVersion", &self.format_version)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ListDevicesRequest { +impl<'de> serde::Deserialize<'de> for ExportZoneStart { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "backend", + "arch", + "format_version", + "formatVersion", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + ZoneId, + Backend, + Arch, + FormatVersion, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5307,7 +5083,13 @@ impl<'de> serde::Deserialize<'de> for ListDevicesRequest { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "backend" => Ok(GeneratedField::Backend), + "arch" => Ok(GeneratedField::Arch), + "formatVersion" | "format_version" => Ok(GeneratedField::FormatVersion), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -5315,27 +5097,62 @@ impl<'de> serde::Deserialize<'de> for ListDevicesRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListDevicesRequest; + type Value = ExportZoneStart; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListDevicesRequest") + formatter.write_str("struct protect.control.v1.ExportZoneStart") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; - } - Ok(ListDevicesRequest { + let mut zone_id__ = None; + let mut backend__ = None; + let mut arch__ = None; + let mut format_version__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Backend => { + if backend__.is_some() { + return Err(serde::de::Error::duplicate_field("backend")); + } + backend__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Arch => { + if arch__.is_some() { + return Err(serde::de::Error::duplicate_field("arch")); + } + arch__ = Some(map_.next_value::()? as i32); + } + GeneratedField::FormatVersion => { + if format_version__.is_some() { + return Err(serde::de::Error::duplicate_field("formatVersion")); + } + format_version__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(ExportZoneStart { + zone_id: zone_id__.unwrap_or_default(), + backend: backend__.unwrap_or_default(), + arch: arch__.unwrap_or_default(), + format_version: format_version__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ListDevicesRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ExportZoneStart", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListImagesReply { +impl serde::Serialize for ForkZoneReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5343,29 +5160,30 @@ impl serde::Serialize for ListImagesReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.images.is_empty() { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListImagesReply", len)?; - if !self.images.is_empty() { - struct_ser.serialize_field("images", &self.images)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ForkZoneReply", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ListImagesReply { +impl<'de> serde::Deserialize<'de> for ForkZoneReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "images", + "zone_id", + "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Images, + ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5387,7 +5205,7 @@ impl<'de> serde::Deserialize<'de> for ListImagesReply { E: serde::de::Error, { match value { - "images" => Ok(GeneratedField::Images), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5397,58 +5215,75 @@ impl<'de> serde::Deserialize<'de> for ListImagesReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListImagesReply; + type Value = ForkZoneReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListImagesReply") + formatter.write_str("struct protect.control.v1.ForkZoneReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut images__ = None; + let mut zone_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Images => { - if images__.is_some() { - return Err(serde::de::Error::duplicate_field("images")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - images__ = Some(map_.next_value()?); + zone_id__ = Some(map_.next_value()?); } } } - Ok(ListImagesReply { - images: images__.unwrap_or_default(), + Ok(ForkZoneReply { + zone_id: zone_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ListImagesReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ForkZoneReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListImagesRequest { +impl serde::Serialize for ForkZoneRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.ListImagesRequest", len)?; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if !self.name.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ForkZoneRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ListImagesRequest { +impl<'de> serde::Deserialize<'de> for ForkZoneRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "name", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + ZoneId, + Name, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5469,7 +5304,11 @@ impl<'de> serde::Deserialize<'de> for ListImagesRequest { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "name" => Ok(GeneratedField::Name), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -5477,27 +5316,44 @@ impl<'de> serde::Deserialize<'de> for ListImagesRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListImagesRequest; + type Value = ForkZoneRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListImagesRequest") + formatter.write_str("struct protect.control.v1.ForkZoneRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut zone_id__ = None; + let mut name__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + } } - Ok(ListImagesRequest { + Ok(ForkZoneRequest { + zone_id: zone_id__.unwrap_or_default(), + name: name__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ListImagesRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ForkZoneRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListNetworkReservationsReply { +impl serde::Serialize for GetHostCpuTopologyReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5505,29 +5361,29 @@ impl serde::Serialize for ListNetworkReservationsReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.reservations.is_empty() { + if !self.cpus.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListNetworkReservationsReply", len)?; - if !self.reservations.is_empty() { - struct_ser.serialize_field("reservations", &self.reservations)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetHostCpuTopologyReply", len)?; + if !self.cpus.is_empty() { + struct_ser.serialize_field("cpus", &self.cpus)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ListNetworkReservationsReply { +impl<'de> serde::Deserialize<'de> for GetHostCpuTopologyReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "reservations", + "cpus", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Reservations, + Cpus, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5549,7 +5405,7 @@ impl<'de> serde::Deserialize<'de> for ListNetworkReservationsReply { E: serde::de::Error, { match value { - "reservations" => Ok(GeneratedField::Reservations), + "cpus" => Ok(GeneratedField::Cpus), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5559,36 +5415,36 @@ impl<'de> serde::Deserialize<'de> for ListNetworkReservationsReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListNetworkReservationsReply; + type Value = GetHostCpuTopologyReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListNetworkReservationsReply") + formatter.write_str("struct protect.control.v1.GetHostCpuTopologyReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut reservations__ = None; + let mut cpus__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Reservations => { - if reservations__.is_some() { - return Err(serde::de::Error::duplicate_field("reservations")); + GeneratedField::Cpus => { + if cpus__.is_some() { + return Err(serde::de::Error::duplicate_field("cpus")); } - reservations__ = Some(map_.next_value()?); + cpus__ = Some(map_.next_value()?); } } } - Ok(ListNetworkReservationsReply { - reservations: reservations__.unwrap_or_default(), + Ok(GetHostCpuTopologyReply { + cpus: cpus__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ListNetworkReservationsReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetHostCpuTopologyReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListNetworkReservationsRequest { +impl serde::Serialize for GetHostCpuTopologyRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5596,11 +5452,11 @@ impl serde::Serialize for ListNetworkReservationsRequest { { use serde::ser::SerializeStruct; let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.ListNetworkReservationsRequest", len)?; + let struct_ser = serializer.serialize_struct("protect.control.v1.GetHostCpuTopologyRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ListNetworkReservationsRequest { +impl<'de> serde::Deserialize<'de> for GetHostCpuTopologyRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where @@ -5639,27 +5495,27 @@ impl<'de> serde::Deserialize<'de> for ListNetworkReservationsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListNetworkReservationsRequest; + type Value = GetHostCpuTopologyRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListNetworkReservationsRequest") + formatter.write_str("struct protect.control.v1.GetHostCpuTopologyRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(ListNetworkReservationsRequest { + Ok(GetHostCpuTopologyRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.ListNetworkReservationsRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetHostCpuTopologyRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListWorkloadsReply { +impl serde::Serialize for GetHostResourcesReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5667,29 +5523,190 @@ impl serde::Serialize for ListWorkloadsReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.workloads.is_empty() { + if self.hypervisor_total_memory != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListWorkloadsReply", len)?; - if !self.workloads.is_empty() { - struct_ser.serialize_field("workloads", &self.workloads)?; + if self.hypervisor_used_memory != 0 { + len += 1; + } + if self.hypervisor_free_memory != 0 { + len += 1; + } + if self.hypervisor_cpu_usage != 0. { + len += 1; + } + if self.hypervisor_cpu_total_time != 0 { + len += 1; + } + if self.hypervisor_numa_nodes != 0 { + len += 1; + } + if self.hypervisor_cpu_sockets != 0 { + len += 1; + } + if self.hypervisor_cpu_cores != 0 { + len += 1; + } + if self.hypervisor_cpu_threads != 0 { + len += 1; + } + if self.host_total_memory != 0 { + len += 1; + } + if self.host_used_memory != 0 { + len += 1; + } + if self.host_free_memory != 0 { + len += 1; + } + if self.host_cpu_usage != 0. { + len += 1; + } + if self.host_cpu_total_time != 0 { + len += 1; + } + if self.host_numa_nodes != 0 { + len += 1; + } + if self.host_cpu_sockets != 0 { + len += 1; + } + if self.host_cpu_cores != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetHostResourcesReply", len)?; + if self.hypervisor_total_memory != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("hypervisorTotalMemory", ToString::to_string(&self.hypervisor_total_memory).as_str())?; + } + if self.hypervisor_used_memory != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("hypervisorUsedMemory", ToString::to_string(&self.hypervisor_used_memory).as_str())?; + } + if self.hypervisor_free_memory != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("hypervisorFreeMemory", ToString::to_string(&self.hypervisor_free_memory).as_str())?; + } + if self.hypervisor_cpu_usage != 0. { + struct_ser.serialize_field("hypervisorCpuUsage", &self.hypervisor_cpu_usage)?; + } + if self.hypervisor_cpu_total_time != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("hypervisorCpuTotalTime", ToString::to_string(&self.hypervisor_cpu_total_time).as_str())?; + } + if self.hypervisor_numa_nodes != 0 { + struct_ser.serialize_field("hypervisorNumaNodes", &self.hypervisor_numa_nodes)?; + } + if self.hypervisor_cpu_sockets != 0 { + struct_ser.serialize_field("hypervisorCpuSockets", &self.hypervisor_cpu_sockets)?; + } + if self.hypervisor_cpu_cores != 0 { + struct_ser.serialize_field("hypervisorCpuCores", &self.hypervisor_cpu_cores)?; + } + if self.hypervisor_cpu_threads != 0 { + struct_ser.serialize_field("hypervisorCpuThreads", &self.hypervisor_cpu_threads)?; + } + if self.host_total_memory != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("hostTotalMemory", ToString::to_string(&self.host_total_memory).as_str())?; + } + if self.host_used_memory != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("hostUsedMemory", ToString::to_string(&self.host_used_memory).as_str())?; + } + if self.host_free_memory != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("hostFreeMemory", ToString::to_string(&self.host_free_memory).as_str())?; + } + if self.host_cpu_usage != 0. { + struct_ser.serialize_field("hostCpuUsage", &self.host_cpu_usage)?; + } + if self.host_cpu_total_time != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("hostCpuTotalTime", ToString::to_string(&self.host_cpu_total_time).as_str())?; + } + if self.host_numa_nodes != 0 { + struct_ser.serialize_field("hostNumaNodes", &self.host_numa_nodes)?; + } + if self.host_cpu_sockets != 0 { + struct_ser.serialize_field("hostCpuSockets", &self.host_cpu_sockets)?; + } + if self.host_cpu_cores != 0 { + struct_ser.serialize_field("hostCpuCores", &self.host_cpu_cores)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ListWorkloadsReply { +impl<'de> serde::Deserialize<'de> for GetHostResourcesReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workloads", + "hypervisor_total_memory", + "hypervisorTotalMemory", + "hypervisor_used_memory", + "hypervisorUsedMemory", + "hypervisor_free_memory", + "hypervisorFreeMemory", + "hypervisor_cpu_usage", + "hypervisorCpuUsage", + "hypervisor_cpu_total_time", + "hypervisorCpuTotalTime", + "hypervisor_numa_nodes", + "hypervisorNumaNodes", + "hypervisor_cpu_sockets", + "hypervisorCpuSockets", + "hypervisor_cpu_cores", + "hypervisorCpuCores", + "hypervisor_cpu_threads", + "hypervisorCpuThreads", + "host_total_memory", + "hostTotalMemory", + "host_used_memory", + "hostUsedMemory", + "host_free_memory", + "hostFreeMemory", + "host_cpu_usage", + "hostCpuUsage", + "host_cpu_total_time", + "hostCpuTotalTime", + "host_numa_nodes", + "hostNumaNodes", + "host_cpu_sockets", + "hostCpuSockets", + "host_cpu_cores", + "hostCpuCores", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Workloads, + HypervisorTotalMemory, + HypervisorUsedMemory, + HypervisorFreeMemory, + HypervisorCpuUsage, + HypervisorCpuTotalTime, + HypervisorNumaNodes, + HypervisorCpuSockets, + HypervisorCpuCores, + HypervisorCpuThreads, + HostTotalMemory, + HostUsedMemory, + HostFreeMemory, + HostCpuUsage, + HostCpuTotalTime, + HostNumaNodes, + HostCpuSockets, + HostCpuCores, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5711,7 +5728,23 @@ impl<'de> serde::Deserialize<'de> for ListWorkloadsReply { E: serde::de::Error, { match value { - "workloads" => Ok(GeneratedField::Workloads), + "hypervisorTotalMemory" | "hypervisor_total_memory" => Ok(GeneratedField::HypervisorTotalMemory), + "hypervisorUsedMemory" | "hypervisor_used_memory" => Ok(GeneratedField::HypervisorUsedMemory), + "hypervisorFreeMemory" | "hypervisor_free_memory" => Ok(GeneratedField::HypervisorFreeMemory), + "hypervisorCpuUsage" | "hypervisor_cpu_usage" => Ok(GeneratedField::HypervisorCpuUsage), + "hypervisorCpuTotalTime" | "hypervisor_cpu_total_time" => Ok(GeneratedField::HypervisorCpuTotalTime), + "hypervisorNumaNodes" | "hypervisor_numa_nodes" => Ok(GeneratedField::HypervisorNumaNodes), + "hypervisorCpuSockets" | "hypervisor_cpu_sockets" => Ok(GeneratedField::HypervisorCpuSockets), + "hypervisorCpuCores" | "hypervisor_cpu_cores" => Ok(GeneratedField::HypervisorCpuCores), + "hypervisorCpuThreads" | "hypervisor_cpu_threads" => Ok(GeneratedField::HypervisorCpuThreads), + "hostTotalMemory" | "host_total_memory" => Ok(GeneratedField::HostTotalMemory), + "hostUsedMemory" | "host_used_memory" => Ok(GeneratedField::HostUsedMemory), + "hostFreeMemory" | "host_free_memory" => Ok(GeneratedField::HostFreeMemory), + "hostCpuUsage" | "host_cpu_usage" => Ok(GeneratedField::HostCpuUsage), + "hostCpuTotalTime" | "host_cpu_total_time" => Ok(GeneratedField::HostCpuTotalTime), + "hostNumaNodes" | "host_numa_nodes" => Ok(GeneratedField::HostNumaNodes), + "hostCpuSockets" | "host_cpu_sockets" => Ok(GeneratedField::HostCpuSockets), + "hostCpuCores" | "host_cpu_cores" => Ok(GeneratedField::HostCpuCores), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5721,36 +5754,198 @@ impl<'de> serde::Deserialize<'de> for ListWorkloadsReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListWorkloadsReply; + type Value = GetHostResourcesReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListWorkloadsReply") + formatter.write_str("struct protect.control.v1.GetHostResourcesReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workloads__ = None; + let mut hypervisor_total_memory__ = None; + let mut hypervisor_used_memory__ = None; + let mut hypervisor_free_memory__ = None; + let mut hypervisor_cpu_usage__ = None; + let mut hypervisor_cpu_total_time__ = None; + let mut hypervisor_numa_nodes__ = None; + let mut hypervisor_cpu_sockets__ = None; + let mut hypervisor_cpu_cores__ = None; + let mut hypervisor_cpu_threads__ = None; + let mut host_total_memory__ = None; + let mut host_used_memory__ = None; + let mut host_free_memory__ = None; + let mut host_cpu_usage__ = None; + let mut host_cpu_total_time__ = None; + let mut host_numa_nodes__ = None; + let mut host_cpu_sockets__ = None; + let mut host_cpu_cores__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Workloads => { - if workloads__.is_some() { - return Err(serde::de::Error::duplicate_field("workloads")); + GeneratedField::HypervisorTotalMemory => { + if hypervisor_total_memory__.is_some() { + return Err(serde::de::Error::duplicate_field("hypervisorTotalMemory")); } - workloads__ = Some(map_.next_value()?); + hypervisor_total_memory__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - } - } - Ok(ListWorkloadsReply { - workloads: workloads__.unwrap_or_default(), + GeneratedField::HypervisorUsedMemory => { + if hypervisor_used_memory__.is_some() { + return Err(serde::de::Error::duplicate_field("hypervisorUsedMemory")); + } + hypervisor_used_memory__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HypervisorFreeMemory => { + if hypervisor_free_memory__.is_some() { + return Err(serde::de::Error::duplicate_field("hypervisorFreeMemory")); + } + hypervisor_free_memory__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HypervisorCpuUsage => { + if hypervisor_cpu_usage__.is_some() { + return Err(serde::de::Error::duplicate_field("hypervisorCpuUsage")); + } + hypervisor_cpu_usage__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HypervisorCpuTotalTime => { + if hypervisor_cpu_total_time__.is_some() { + return Err(serde::de::Error::duplicate_field("hypervisorCpuTotalTime")); + } + hypervisor_cpu_total_time__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HypervisorNumaNodes => { + if hypervisor_numa_nodes__.is_some() { + return Err(serde::de::Error::duplicate_field("hypervisorNumaNodes")); + } + hypervisor_numa_nodes__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HypervisorCpuSockets => { + if hypervisor_cpu_sockets__.is_some() { + return Err(serde::de::Error::duplicate_field("hypervisorCpuSockets")); + } + hypervisor_cpu_sockets__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HypervisorCpuCores => { + if hypervisor_cpu_cores__.is_some() { + return Err(serde::de::Error::duplicate_field("hypervisorCpuCores")); + } + hypervisor_cpu_cores__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HypervisorCpuThreads => { + if hypervisor_cpu_threads__.is_some() { + return Err(serde::de::Error::duplicate_field("hypervisorCpuThreads")); + } + hypervisor_cpu_threads__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HostTotalMemory => { + if host_total_memory__.is_some() { + return Err(serde::de::Error::duplicate_field("hostTotalMemory")); + } + host_total_memory__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HostUsedMemory => { + if host_used_memory__.is_some() { + return Err(serde::de::Error::duplicate_field("hostUsedMemory")); + } + host_used_memory__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HostFreeMemory => { + if host_free_memory__.is_some() { + return Err(serde::de::Error::duplicate_field("hostFreeMemory")); + } + host_free_memory__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HostCpuUsage => { + if host_cpu_usage__.is_some() { + return Err(serde::de::Error::duplicate_field("hostCpuUsage")); + } + host_cpu_usage__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HostCpuTotalTime => { + if host_cpu_total_time__.is_some() { + return Err(serde::de::Error::duplicate_field("hostCpuTotalTime")); + } + host_cpu_total_time__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HostNumaNodes => { + if host_numa_nodes__.is_some() { + return Err(serde::de::Error::duplicate_field("hostNumaNodes")); + } + host_numa_nodes__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HostCpuSockets => { + if host_cpu_sockets__.is_some() { + return Err(serde::de::Error::duplicate_field("hostCpuSockets")); + } + host_cpu_sockets__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HostCpuCores => { + if host_cpu_cores__.is_some() { + return Err(serde::de::Error::duplicate_field("hostCpuCores")); + } + host_cpu_cores__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(GetHostResourcesReply { + hypervisor_total_memory: hypervisor_total_memory__.unwrap_or_default(), + hypervisor_used_memory: hypervisor_used_memory__.unwrap_or_default(), + hypervisor_free_memory: hypervisor_free_memory__.unwrap_or_default(), + hypervisor_cpu_usage: hypervisor_cpu_usage__.unwrap_or_default(), + hypervisor_cpu_total_time: hypervisor_cpu_total_time__.unwrap_or_default(), + hypervisor_numa_nodes: hypervisor_numa_nodes__.unwrap_or_default(), + hypervisor_cpu_sockets: hypervisor_cpu_sockets__.unwrap_or_default(), + hypervisor_cpu_cores: hypervisor_cpu_cores__.unwrap_or_default(), + hypervisor_cpu_threads: hypervisor_cpu_threads__.unwrap_or_default(), + host_total_memory: host_total_memory__.unwrap_or_default(), + host_used_memory: host_used_memory__.unwrap_or_default(), + host_free_memory: host_free_memory__.unwrap_or_default(), + host_cpu_usage: host_cpu_usage__.unwrap_or_default(), + host_cpu_total_time: host_cpu_total_time__.unwrap_or_default(), + host_numa_nodes: host_numa_nodes__.unwrap_or_default(), + host_cpu_sockets: host_cpu_sockets__.unwrap_or_default(), + host_cpu_cores: host_cpu_cores__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ListWorkloadsReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetHostResourcesReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListWorkloadsRequest { +impl serde::Serialize for GetHostResourcesRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5758,11 +5953,11 @@ impl serde::Serialize for ListWorkloadsRequest { { use serde::ser::SerializeStruct; let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.ListWorkloadsRequest", len)?; + let struct_ser = serializer.serialize_struct("protect.control.v1.GetHostResourcesRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ListWorkloadsRequest { +impl<'de> serde::Deserialize<'de> for GetHostResourcesRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where @@ -5801,27 +5996,27 @@ impl<'de> serde::Deserialize<'de> for ListWorkloadsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListWorkloadsRequest; + type Value = GetHostResourcesRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListWorkloadsRequest") + formatter.write_str("struct protect.control.v1.GetHostResourcesRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(ListWorkloadsRequest { + Ok(GetHostResourcesRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.ListWorkloadsRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetHostResourcesRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListZonesReply { +impl serde::Serialize for GetHostStatusReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5829,29 +6024,124 @@ impl serde::Serialize for ListZonesReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zones.is_empty() { + if !self.host_uuid.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListZonesReply", len)?; - if !self.zones.is_empty() { - struct_ser.serialize_field("zones", &self.zones)?; + if self.host_domid != 0 { + len += 1; + } + if !self.protect_version.is_empty() { + len += 1; + } + if !self.host_ipv4.is_empty() { + len += 1; + } + if !self.host_ipv6.is_empty() { + len += 1; + } + if !self.host_mac.is_empty() { + len += 1; + } + 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)?; + } + if self.host_domid != 0 { + struct_ser.serialize_field("hostDomid", &self.host_domid)?; + } + if !self.protect_version.is_empty() { + struct_ser.serialize_field("protectVersion", &self.protect_version)?; + } + if !self.host_ipv4.is_empty() { + struct_ser.serialize_field("hostIpv4", &self.host_ipv4)?; + } + if !self.host_ipv6.is_empty() { + struct_ser.serialize_field("hostIpv6", &self.host_ipv6)?; + } + if !self.host_mac.is_empty() { + struct_ser.serialize_field("hostMac", &self.host_mac)?; + } + if let Some(v) = self.hyp_free_mem.as_ref() { + #[allow(clippy::needless_borrow)] + #[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() } } -impl<'de> serde::Deserialize<'de> for ListZonesReply { +impl<'de> serde::Deserialize<'de> for GetHostStatusReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zones", + "host_uuid", + "hostUuid", + "host_domid", + "hostDomid", + "protect_version", + "protectVersion", + "host_ipv4", + "hostIpv4", + "host_ipv6", + "hostIpv6", + "host_mac", + "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)] enum GeneratedField { - Zones, + HostUuid, + HostDomid, + ProtectVersion, + HostIpv4, + HostIpv6, + HostMac, + HypFreeMem, + ProtectGitSha, + ProtectLastTag, + ProtectRevsSinceTag, + ProtectBranch, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5873,7 +6163,17 @@ impl<'de> serde::Deserialize<'de> for ListZonesReply { E: serde::de::Error, { match value { - "zones" => Ok(GeneratedField::Zones), + "hostUuid" | "host_uuid" => Ok(GeneratedField::HostUuid), + "hostDomid" | "host_domid" => Ok(GeneratedField::HostDomid), + "protectVersion" | "protect_version" => Ok(GeneratedField::ProtectVersion), + "hostIpv4" | "host_ipv4" => Ok(GeneratedField::HostIpv4), + "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)), } } @@ -5883,56 +6183,142 @@ impl<'de> serde::Deserialize<'de> for ListZonesReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListZonesReply; + type Value = GetHostStatusReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListZonesReply") + formatter.write_str("struct protect.control.v1.GetHostStatusReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zones__ = None; + let mut host_uuid__ = None; + let mut host_domid__ = None; + let mut protect_version__ = None; + let mut host_ipv4__ = None; + 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::Zones => { - if zones__.is_some() { - return Err(serde::de::Error::duplicate_field("zones")); + GeneratedField::HostUuid => { + if host_uuid__.is_some() { + return Err(serde::de::Error::duplicate_field("hostUuid")); } - zones__ = Some(map_.next_value()?); + host_uuid__ = Some(map_.next_value()?); } - } - } - Ok(ListZonesReply { - zones: zones__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("protect.control.v1.ListZonesReply", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ListZonesRequest { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.ListZonesRequest", len)?; - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ListZonesRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - ]; - + GeneratedField::HostDomid => { + if host_domid__.is_some() { + return Err(serde::de::Error::duplicate_field("hostDomid")); + } + host_domid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ProtectVersion => { + if protect_version__.is_some() { + return Err(serde::de::Error::duplicate_field("protectVersion")); + } + protect_version__ = Some(map_.next_value()?); + } + GeneratedField::HostIpv4 => { + if host_ipv4__.is_some() { + return Err(serde::de::Error::duplicate_field("hostIpv4")); + } + host_ipv4__ = Some(map_.next_value()?); + } + GeneratedField::HostIpv6 => { + if host_ipv6__.is_some() { + return Err(serde::de::Error::duplicate_field("hostIpv6")); + } + host_ipv6__ = Some(map_.next_value()?); + } + GeneratedField::HostMac => { + if host_mac__.is_some() { + return Err(serde::de::Error::duplicate_field("hostMac")); + } + host_mac__ = Some(map_.next_value()?); + } + GeneratedField::HypFreeMem => { + if hyp_free_mem__.is_some() { + return Err(serde::de::Error::duplicate_field("hypFreeMem")); + } + hyp_free_mem__ = + 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 { + host_uuid: host_uuid__.unwrap_or_default(), + host_domid: host_domid__.unwrap_or_default(), + protect_version: protect_version__.unwrap_or_default(), + host_ipv4: host_ipv4__.unwrap_or_default(), + 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__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.GetHostStatusReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GetHostStatusRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.GetHostStatusRequest", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for GetHostStatusRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + #[allow(clippy::enum_variant_names)] enum GeneratedField { } @@ -5963,107 +6349,27 @@ impl<'de> serde::Deserialize<'de> for ListZonesRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListZonesRequest; + type Value = GetHostStatusRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ListZonesRequest") + formatter.write_str("struct protect.control.v1.GetHostStatusRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(ListZonesRequest { + Ok(GetHostStatusRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.ListZonesRequest", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for MetricFormat { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Unknown => "METRIC_FORMAT_UNKNOWN", - Self::Bytes => "METRIC_FORMAT_BYTES", - Self::Integer => "METRIC_FORMAT_INTEGER", - Self::DurationSeconds => "METRIC_FORMAT_DURATION_SECONDS", - Self::Percent => "METRIC_FORMAT_PERCENT", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for MetricFormat { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "METRIC_FORMAT_UNKNOWN", - "METRIC_FORMAT_BYTES", - "METRIC_FORMAT_INTEGER", - "METRIC_FORMAT_DURATION_SECONDS", - "METRIC_FORMAT_PERCENT", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MetricFormat; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "METRIC_FORMAT_UNKNOWN" => Ok(MetricFormat::Unknown), - "METRIC_FORMAT_BYTES" => Ok(MetricFormat::Bytes), - "METRIC_FORMAT_INTEGER" => Ok(MetricFormat::Integer), - "METRIC_FORMAT_DURATION_SECONDS" => Ok(MetricFormat::DurationSeconds), - "METRIC_FORMAT_PERCENT" => Ok(MetricFormat::Percent), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetHostStatusRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MetricNode { +impl serde::Serialize for GetWorkloadReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6071,55 +6377,29 @@ impl serde::Serialize for MetricNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if self.value.is_some() { - len += 1; - } - if self.format != 0 { - len += 1; - } - if !self.children.is_empty() { + if self.workload.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.MetricNode", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if let Some(v) = self.value.as_ref() { - struct_ser.serialize_field("value", v)?; - } - if self.format != 0 { - let v = MetricFormat::try_from(self.format) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; - struct_ser.serialize_field("format", &v)?; - } - if !self.children.is_empty() { - struct_ser.serialize_field("children", &self.children)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetWorkloadReply", len)?; + if let Some(v) = self.workload.as_ref() { + struct_ser.serialize_field("workload", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MetricNode { +impl<'de> serde::Deserialize<'de> for GetWorkloadReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", - "value", - "format", - "children", + "workload", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, - Value, - Format, - Children, + Workload, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6141,10 +6421,7 @@ impl<'de> serde::Deserialize<'de> for MetricNode { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), - "value" => Ok(GeneratedField::Value), - "format" => Ok(GeneratedField::Format), - "children" => Ok(GeneratedField::Children), + "workload" => Ok(GeneratedField::Workload), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6154,60 +6431,36 @@ impl<'de> serde::Deserialize<'de> for MetricNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MetricNode; + type Value = GetWorkloadReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.MetricNode") + formatter.write_str("struct protect.control.v1.GetWorkloadReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; - let mut value__ = None; - let mut format__ = None; - let mut children__ = None; + let mut workload__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map_.next_value()?); - } - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); - } - value__ = map_.next_value()?; - } - GeneratedField::Format => { - if format__.is_some() { - return Err(serde::de::Error::duplicate_field("format")); - } - format__ = Some(map_.next_value::()? as i32); - } - GeneratedField::Children => { - if children__.is_some() { - return Err(serde::de::Error::duplicate_field("children")); + GeneratedField::Workload => { + if workload__.is_some() { + return Err(serde::de::Error::duplicate_field("workload")); } - children__ = Some(map_.next_value()?); + workload__ = map_.next_value()?; } } } - Ok(MetricNode { - name: name__.unwrap_or_default(), - value: value__, - format: format__.unwrap_or_default(), - children: children__.unwrap_or_default(), + Ok(GetWorkloadReply { + workload: workload__, }) } } - deserializer.deserialize_struct("protect.control.v1.MetricNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetWorkloadReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MonitorZoneKernelEventReply { +impl serde::Serialize for GetWorkloadRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6215,38 +6468,30 @@ impl serde::Serialize for MonitorZoneKernelEventReply { { use serde::ser::SerializeStruct; let mut len = 0; - if self.reply.is_some() { + if !self.workload_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.MonitorZoneKernelEventReply", len)?; - if let Some(v) = self.reply.as_ref() { - match v { - monitor_zone_kernel_event_reply::Reply::Syscall(v) => { - struct_ser.serialize_field("syscall", v)?; - } - monitor_zone_kernel_event_reply::Reply::Threadsnap(v) => { - struct_ser.serialize_field("threadsnap", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetWorkloadRequest", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MonitorZoneKernelEventReply { +impl<'de> serde::Deserialize<'de> for GetWorkloadRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "syscall", - "threadsnap", + "workload_id", + "workloadId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Syscall, - Threadsnap, + WorkloadId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6268,8 +6513,7 @@ impl<'de> serde::Deserialize<'de> for MonitorZoneKernelEventReply { E: serde::de::Error, { match value { - "syscall" => Ok(GeneratedField::Syscall), - "threadsnap" => Ok(GeneratedField::Threadsnap), + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6279,44 +6523,36 @@ impl<'de> serde::Deserialize<'de> for MonitorZoneKernelEventReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MonitorZoneKernelEventReply; + type Value = GetWorkloadRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.MonitorZoneKernelEventReply") + formatter.write_str("struct protect.control.v1.GetWorkloadRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut reply__ = None; + let mut workload_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Syscall => { - if reply__.is_some() { - return Err(serde::de::Error::duplicate_field("syscall")); - } - reply__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_reply::Reply::Syscall) -; - } - GeneratedField::Threadsnap => { - if reply__.is_some() { - return Err(serde::de::Error::duplicate_field("threadsnap")); + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); } - reply__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_reply::Reply::Threadsnap) -; + workload_id__ = Some(map_.next_value()?); } } } - Ok(MonitorZoneKernelEventReply { - reply: reply__, + Ok(GetWorkloadRequest { + workload_id: workload_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.MonitorZoneKernelEventReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetWorkloadRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MonitorZoneKernelEventRequest { +impl serde::Serialize for GetZoneReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6324,47 +6560,29 @@ impl serde::Serialize for MonitorZoneKernelEventRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { - len += 1; - } - if self.request.is_some() { + if self.zone.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.MonitorZoneKernelEventRequest", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; - } - if let Some(v) = self.request.as_ref() { - match v { - monitor_zone_kernel_event_request::Request::Update(v) => { - struct_ser.serialize_field("update", v)?; - } - monitor_zone_kernel_event_request::Request::Stop(v) => { - struct_ser.serialize_field("stop", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetZoneReply", len)?; + if let Some(v) = self.zone.as_ref() { + struct_ser.serialize_field("zone", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MonitorZoneKernelEventRequest { +impl<'de> serde::Deserialize<'de> for GetZoneReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", - "update", - "stop", + "zone", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, - Update, - Stop, + Zone, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6386,9 +6604,7 @@ impl<'de> serde::Deserialize<'de> for MonitorZoneKernelEventRequest { E: serde::de::Error, { match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - "update" => Ok(GeneratedField::Update), - "stop" => Ok(GeneratedField::Stop), + "zone" => Ok(GeneratedField::Zone), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6398,52 +6614,36 @@ impl<'de> serde::Deserialize<'de> for MonitorZoneKernelEventRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MonitorZoneKernelEventRequest; + type Value = GetZoneReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.MonitorZoneKernelEventRequest") + formatter.write_str("struct protect.control.v1.GetZoneReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - let mut request__ = None; + let mut zone__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); - } - zone_id__ = Some(map_.next_value()?); - } - GeneratedField::Update => { - if request__.is_some() { - return Err(serde::de::Error::duplicate_field("update")); - } - request__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_request::Request::Update) -; - } - GeneratedField::Stop => { - if request__.is_some() { - return Err(serde::de::Error::duplicate_field("stop")); + GeneratedField::Zone => { + if zone__.is_some() { + return Err(serde::de::Error::duplicate_field("zone")); } - request__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_request::Request::Stop) -; + zone__ = map_.next_value()?; } } } - Ok(MonitorZoneKernelEventRequest { - zone_id: zone_id__.unwrap_or_default(), - request: request__, + Ok(GetZoneReply { + zone: zone__, }) } } - deserializer.deserialize_struct("protect.control.v1.MonitorZoneKernelEventRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetZoneReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MountSpec { +impl serde::Serialize for GetZoneRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6451,39 +6651,30 @@ impl serde::Serialize for MountSpec { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.host_path.is_empty() { - len += 1; - } - if !self.target_path.is_empty() { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.MountSpec", len)?; - if !self.host_path.is_empty() { - struct_ser.serialize_field("hostPath", &self.host_path)?; - } - if !self.target_path.is_empty() { - struct_ser.serialize_field("targetPath", &self.target_path)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetZoneRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MountSpec { +impl<'de> serde::Deserialize<'de> for GetZoneRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "host_path", - "hostPath", - "target_path", - "targetPath", + "zone_id", + "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - HostPath, - TargetPath, + ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6505,8 +6696,7 @@ impl<'de> serde::Deserialize<'de> for MountSpec { E: serde::de::Error, { match value { - "hostPath" | "host_path" => Ok(GeneratedField::HostPath), - "targetPath" | "target_path" => Ok(GeneratedField::TargetPath), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6516,44 +6706,36 @@ impl<'de> serde::Deserialize<'de> for MountSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MountSpec; + type Value = GetZoneRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.MountSpec") + formatter.write_str("struct protect.control.v1.GetZoneRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut host_path__ = None; - let mut target_path__ = None; + let mut zone_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::HostPath => { - if host_path__.is_some() { - return Err(serde::de::Error::duplicate_field("hostPath")); - } - host_path__ = Some(map_.next_value()?); - } - GeneratedField::TargetPath => { - if target_path__.is_some() { - return Err(serde::de::Error::duplicate_field("targetPath")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - target_path__ = Some(map_.next_value()?); + zone_id__ = Some(map_.next_value()?); } } } - Ok(MountSpec { - host_path: host_path__.unwrap_or_default(), - target_path: target_path__.unwrap_or_default(), + Ok(GetZoneRequest { + zone_id: zone_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.MountSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetZoneRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for NetworkReservation { +impl serde::Serialize for GetZonesVcpuInfosReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6561,80 +6743,122 @@ impl serde::Serialize for NetworkReservation { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.uuid.is_empty() { - len += 1; - } - if !self.ipv4.is_empty() { - len += 1; - } - if !self.ipv6.is_empty() { + if !self.vcpu_info_sets.is_empty() { len += 1; } - if !self.mac.is_empty() { - len += 1; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetZonesVcpuInfosReply", len)?; + if !self.vcpu_info_sets.is_empty() { + struct_ser.serialize_field("vcpuInfoSets", &self.vcpu_info_sets)?; } - if !self.gateway_ipv4.is_empty() { - len += 1; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for GetZonesVcpuInfosReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "vcpu_info_sets", + "vcpuInfoSets", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + VcpuInfoSets, } - if !self.gateway_ipv6.is_empty() { - len += 1; - } - if !self.gateway_mac.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.NetworkReservation", len)?; - if !self.uuid.is_empty() { - struct_ser.serialize_field("uuid", &self.uuid)?; - } - if !self.ipv4.is_empty() { - struct_ser.serialize_field("ipv4", &self.ipv4)?; - } - if !self.ipv6.is_empty() { - struct_ser.serialize_field("ipv6", &self.ipv6)?; - } - if !self.mac.is_empty() { - struct_ser.serialize_field("mac", &self.mac)?; + 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 { + "vcpuInfoSets" | "vcpu_info_sets" => Ok(GeneratedField::VcpuInfoSets), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if !self.gateway_ipv4.is_empty() { - struct_ser.serialize_field("gatewayIpv4", &self.gateway_ipv4)?; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GetZonesVcpuInfosReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.GetZonesVcpuInfosReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut vcpu_info_sets__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::VcpuInfoSets => { + if vcpu_info_sets__.is_some() { + return Err(serde::de::Error::duplicate_field("vcpuInfoSets")); + } + vcpu_info_sets__ = Some(map_.next_value()?); + } + } + } + Ok(GetZonesVcpuInfosReply { + vcpu_info_sets: vcpu_info_sets__.unwrap_or_default(), + }) + } } - if !self.gateway_ipv6.is_empty() { - struct_ser.serialize_field("gatewayIpv6", &self.gateway_ipv6)?; + deserializer.deserialize_struct("protect.control.v1.GetZonesVcpuInfosReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GetZonesVcpuInfosRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_ids.is_empty() { + len += 1; } - if !self.gateway_mac.is_empty() { - struct_ser.serialize_field("gatewayMac", &self.gateway_mac)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.GetZonesVcpuInfosRequest", len)?; + if !self.zone_ids.is_empty() { + struct_ser.serialize_field("zoneIds", &self.zone_ids)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for NetworkReservation { +impl<'de> serde::Deserialize<'de> for GetZonesVcpuInfosRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "uuid", - "ipv4", - "ipv6", - "mac", - "gateway_ipv4", - "gatewayIpv4", - "gateway_ipv6", - "gatewayIpv6", - "gateway_mac", - "gatewayMac", + "zone_ids", + "zoneIds", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Uuid, - Ipv4, - Ipv6, - Mac, - GatewayIpv4, - GatewayIpv6, - GatewayMac, + ZoneIds, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6656,13 +6880,7 @@ impl<'de> serde::Deserialize<'de> for NetworkReservation { E: serde::de::Error, { match value { - "uuid" => Ok(GeneratedField::Uuid), - "ipv4" => Ok(GeneratedField::Ipv4), - "ipv6" => Ok(GeneratedField::Ipv6), - "mac" => Ok(GeneratedField::Mac), - "gatewayIpv4" | "gateway_ipv4" => Ok(GeneratedField::GatewayIpv4), - "gatewayIpv6" | "gateway_ipv6" => Ok(GeneratedField::GatewayIpv6), - "gatewayMac" | "gateway_mac" => Ok(GeneratedField::GatewayMac), + "zoneIds" | "zone_ids" => Ok(GeneratedField::ZoneIds), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6672,117 +6890,65 @@ impl<'de> serde::Deserialize<'de> for NetworkReservation { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = NetworkReservation; + type Value = GetZonesVcpuInfosRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.NetworkReservation") + formatter.write_str("struct protect.control.v1.GetZonesVcpuInfosRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut uuid__ = None; - let mut ipv4__ = None; - let mut ipv6__ = None; - let mut mac__ = None; - let mut gateway_ipv4__ = None; - let mut gateway_ipv6__ = None; - let mut gateway_mac__ = None; + let mut zone_ids__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Uuid => { - if uuid__.is_some() { - return Err(serde::de::Error::duplicate_field("uuid")); - } - uuid__ = Some(map_.next_value()?); - } - GeneratedField::Ipv4 => { - if ipv4__.is_some() { - return Err(serde::de::Error::duplicate_field("ipv4")); - } - ipv4__ = Some(map_.next_value()?); - } - GeneratedField::Ipv6 => { - if ipv6__.is_some() { - return Err(serde::de::Error::duplicate_field("ipv6")); - } - ipv6__ = Some(map_.next_value()?); - } - GeneratedField::Mac => { - if mac__.is_some() { - return Err(serde::de::Error::duplicate_field("mac")); - } - mac__ = Some(map_.next_value()?); - } - GeneratedField::GatewayIpv4 => { - if gateway_ipv4__.is_some() { - return Err(serde::de::Error::duplicate_field("gatewayIpv4")); - } - gateway_ipv4__ = Some(map_.next_value()?); - } - GeneratedField::GatewayIpv6 => { - if gateway_ipv6__.is_some() { - return Err(serde::de::Error::duplicate_field("gatewayIpv6")); - } - gateway_ipv6__ = Some(map_.next_value()?); - } - GeneratedField::GatewayMac => { - if gateway_mac__.is_some() { - return Err(serde::de::Error::duplicate_field("gatewayMac")); + GeneratedField::ZoneIds => { + if zone_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneIds")); } - gateway_mac__ = Some(map_.next_value()?); + zone_ids__ = Some(map_.next_value()?); } } } - Ok(NetworkReservation { - uuid: uuid__.unwrap_or_default(), - ipv4: ipv4__.unwrap_or_default(), - ipv6: ipv6__.unwrap_or_default(), - mac: mac__.unwrap_or_default(), - gateway_ipv4: gateway_ipv4__.unwrap_or_default(), - gateway_ipv6: gateway_ipv6__.unwrap_or_default(), - gateway_mac: gateway_mac__.unwrap_or_default(), + Ok(GetZonesVcpuInfosRequest { + zone_ids: zone_ids__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.NetworkReservation", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.GetZonesVcpuInfosRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageFormat { +impl serde::Serialize for HostCpuTopologyClass { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { let variant = match self { - Self::Unknown => "OCI_IMAGE_FORMAT_UNKNOWN", - Self::Squashfs => "OCI_IMAGE_FORMAT_SQUASHFS", - Self::Erofs => "OCI_IMAGE_FORMAT_EROFS", - Self::Tar => "OCI_IMAGE_FORMAT_TAR", - Self::Directory => "OCI_IMAGE_FORMAT_DIRECTORY", + Self::Standard => "HOST_CPU_TOPOLOGY_CLASS_STANDARD", + Self::Performance => "HOST_CPU_TOPOLOGY_CLASS_PERFORMANCE", + Self::Efficiency => "HOST_CPU_TOPOLOGY_CLASS_EFFICIENCY", }; serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for OciImageFormat { +impl<'de> serde::Deserialize<'de> for HostCpuTopologyClass { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "OCI_IMAGE_FORMAT_UNKNOWN", - "OCI_IMAGE_FORMAT_SQUASHFS", - "OCI_IMAGE_FORMAT_EROFS", - "OCI_IMAGE_FORMAT_TAR", - "OCI_IMAGE_FORMAT_DIRECTORY", + "HOST_CPU_TOPOLOGY_CLASS_STANDARD", + "HOST_CPU_TOPOLOGY_CLASS_PERFORMANCE", + "HOST_CPU_TOPOLOGY_CLASS_EFFICIENCY", ]; struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageFormat; + type Value = HostCpuTopologyClass; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(formatter, "expected one of: {:?}", &FIELDS) @@ -6817,11 +6983,9 @@ impl<'de> serde::Deserialize<'de> for OciImageFormat { E: serde::de::Error, { match value { - "OCI_IMAGE_FORMAT_UNKNOWN" => Ok(OciImageFormat::Unknown), - "OCI_IMAGE_FORMAT_SQUASHFS" => Ok(OciImageFormat::Squashfs), - "OCI_IMAGE_FORMAT_EROFS" => Ok(OciImageFormat::Erofs), - "OCI_IMAGE_FORMAT_TAR" => Ok(OciImageFormat::Tar), - "OCI_IMAGE_FORMAT_DIRECTORY" => Ok(OciImageFormat::Directory), + "HOST_CPU_TOPOLOGY_CLASS_STANDARD" => Ok(HostCpuTopologyClass::Standard), + "HOST_CPU_TOPOLOGY_CLASS_PERFORMANCE" => Ok(HostCpuTopologyClass::Performance), + "HOST_CPU_TOPOLOGY_CLASS_EFFICIENCY" => Ok(HostCpuTopologyClass::Efficiency), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -6829,7 +6993,7 @@ impl<'de> serde::Deserialize<'de> for OciImageFormat { deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for OciImageInfo { +impl serde::Serialize for HostCpuTopologyInfo { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6837,56 +7001,64 @@ impl serde::Serialize for OciImageInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.digest.is_empty() { + if self.core != 0 { len += 1; } - if self.format != 0 { + if self.socket != 0 { len += 1; } - if !self.names.is_empty() { + if self.node != 0 { len += 1; } - if self.metadata.is_some() { + if self.thread != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageInfo", len)?; - if !self.digest.is_empty() { - struct_ser.serialize_field("digest", &self.digest)?; + if self.class != 0 { + len += 1; } - if self.format != 0 { - let v = OciImageFormat::try_from(self.format) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; - struct_ser.serialize_field("format", &v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.HostCpuTopologyInfo", len)?; + if self.core != 0 { + struct_ser.serialize_field("core", &self.core)?; } - if !self.names.is_empty() { - struct_ser.serialize_field("names", &self.names)?; + if self.socket != 0 { + struct_ser.serialize_field("socket", &self.socket)?; } - if let Some(v) = self.metadata.as_ref() { - struct_ser.serialize_field("metadata", v)?; + if self.node != 0 { + struct_ser.serialize_field("node", &self.node)?; + } + if self.thread != 0 { + struct_ser.serialize_field("thread", &self.thread)?; + } + if self.class != 0 { + let v = HostCpuTopologyClass::try_from(self.class) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.class)))?; + struct_ser.serialize_field("class", &v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageInfo { +impl<'de> serde::Deserialize<'de> for HostCpuTopologyInfo { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "digest", - "format", - "names", - "metadata", + "core", + "socket", + "node", + "thread", + "class", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Digest, - Format, - Names, - Metadata, - } + Core, + Socket, + Node, + Thread, + Class, + } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result where @@ -6907,10 +7079,11 @@ impl<'de> serde::Deserialize<'de> for OciImageInfo { E: serde::de::Error, { match value { - "digest" => Ok(GeneratedField::Digest), - "format" => Ok(GeneratedField::Format), - "names" => Ok(GeneratedField::Names), - "metadata" => Ok(GeneratedField::Metadata), + "core" => Ok(GeneratedField::Core), + "socket" => Ok(GeneratedField::Socket), + "node" => Ok(GeneratedField::Node), + "thread" => Ok(GeneratedField::Thread), + "class" => Ok(GeneratedField::Class), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6920,60 +7093,76 @@ impl<'de> serde::Deserialize<'de> for OciImageInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageInfo; + type Value = HostCpuTopologyInfo; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageInfo") + formatter.write_str("struct protect.control.v1.HostCpuTopologyInfo") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut digest__ = None; - let mut format__ = None; - let mut names__ = None; - let mut metadata__ = None; + let mut core__ = None; + let mut socket__ = None; + let mut node__ = None; + let mut thread__ = None; + let mut class__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Digest => { - if digest__.is_some() { - return Err(serde::de::Error::duplicate_field("digest")); + GeneratedField::Core => { + if core__.is_some() { + return Err(serde::de::Error::duplicate_field("core")); } - digest__ = Some(map_.next_value()?); + core__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Format => { - if format__.is_some() { - return Err(serde::de::Error::duplicate_field("format")); + GeneratedField::Socket => { + if socket__.is_some() { + return Err(serde::de::Error::duplicate_field("socket")); } - format__ = Some(map_.next_value::()? as i32); + socket__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Names => { - if names__.is_some() { - return Err(serde::de::Error::duplicate_field("names")); + GeneratedField::Node => { + if node__.is_some() { + return Err(serde::de::Error::duplicate_field("node")); } - names__ = Some(map_.next_value()?); + node__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Metadata => { - if metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("metadata")); + GeneratedField::Thread => { + if thread__.is_some() { + return Err(serde::de::Error::duplicate_field("thread")); } - metadata__ = map_.next_value()?; + thread__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Class => { + if class__.is_some() { + return Err(serde::de::Error::duplicate_field("class")); + } + class__ = Some(map_.next_value::()? as i32); } } } - Ok(OciImageInfo { - digest: digest__.unwrap_or_default(), - format: format__.unwrap_or_default(), - names: names__.unwrap_or_default(), - metadata: metadata__, + Ok(HostCpuTopologyInfo { + core: core__.unwrap_or_default(), + socket: socket__.unwrap_or_default(), + node: node__.unwrap_or_default(), + thread: thread__.unwrap_or_default(), + class: class__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.HostCpuTopologyInfo", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageMetadata { +impl serde::Serialize for HypervisorDebugInfoReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6981,41 +7170,29 @@ impl serde::Serialize for OciImageMetadata { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.manifest.is_empty() { - len += 1; - } - if !self.config.is_empty() { + if !self.json.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageMetadata", len)?; - if !self.manifest.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("manifest", pbjson::private::base64::encode(&self.manifest).as_str())?; - } - if !self.config.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("config", pbjson::private::base64::encode(&self.config).as_str())?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.HypervisorDebugInfoReply", len)?; + if !self.json.is_empty() { + struct_ser.serialize_field("json", &self.json)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageMetadata { +impl<'de> serde::Deserialize<'de> for HypervisorDebugInfoReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "manifest", - "config", + "json", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Manifest, - Config, + Json, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7037,8 +7214,7 @@ impl<'de> serde::Deserialize<'de> for OciImageMetadata { E: serde::de::Error, { match value { - "manifest" => Ok(GeneratedField::Manifest), - "config" => Ok(GeneratedField::Config), + "json" => Ok(GeneratedField::Json), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7048,96 +7224,58 @@ impl<'de> serde::Deserialize<'de> for OciImageMetadata { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageMetadata; + type Value = HypervisorDebugInfoReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageMetadata") + formatter.write_str("struct protect.control.v1.HypervisorDebugInfoReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut manifest__ = None; - let mut config__ = None; + let mut json__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Manifest => { - if manifest__.is_some() { - return Err(serde::de::Error::duplicate_field("manifest")); - } - manifest__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::Config => { - if config__.is_some() { - return Err(serde::de::Error::duplicate_field("config")); + GeneratedField::Json => { + if json__.is_some() { + return Err(serde::de::Error::duplicate_field("json")); } - config__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + json__ = Some(map_.next_value()?); } } } - Ok(OciImageMetadata { - manifest: manifest__.unwrap_or_default(), - config: config__.unwrap_or_default(), + Ok(HypervisorDebugInfoReply { + json: json__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageMetadata", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.HypervisorDebugInfoReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageProgress { +impl serde::Serialize for HypervisorDebugInfoRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if self.phase != 0 { - len += 1; - } - if !self.layers.is_empty() { - len += 1; - } - if self.indication.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgress", len)?; - if self.phase != 0 { - let v = OciImageProgressPhase::try_from(self.phase) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.phase)))?; - struct_ser.serialize_field("phase", &v)?; - } - if !self.layers.is_empty() { - struct_ser.serialize_field("layers", &self.layers)?; - } - if let Some(v) = self.indication.as_ref() { - struct_ser.serialize_field("indication", v)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.HypervisorDebugInfoRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageProgress { +impl<'de> serde::Deserialize<'de> for HypervisorDebugInfoRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "phase", - "layers", - "indication", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Phase, - Layers, - Indication, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7158,12 +7296,7 @@ impl<'de> serde::Deserialize<'de> for OciImageProgress { where E: serde::de::Error, { - match value { - "phase" => Ok(GeneratedField::Phase), - "layers" => Ok(GeneratedField::Layers), - "indication" => Ok(GeneratedField::Indication), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -7171,52 +7304,27 @@ impl<'de> serde::Deserialize<'de> for OciImageProgress { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageProgress; + type Value = HypervisorDebugInfoRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageProgress") + formatter.write_str("struct protect.control.v1.HypervisorDebugInfoRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut phase__ = None; - let mut layers__ = None; - let mut indication__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Phase => { - if phase__.is_some() { - return Err(serde::de::Error::duplicate_field("phase")); - } - phase__ = Some(map_.next_value::()? as i32); - } - GeneratedField::Layers => { - if layers__.is_some() { - return Err(serde::de::Error::duplicate_field("layers")); - } - layers__ = Some(map_.next_value()?); - } - GeneratedField::Indication => { - if indication__.is_some() { - return Err(serde::de::Error::duplicate_field("indication")); - } - indication__ = map_.next_value()?; - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(OciImageProgress { - phase: phase__.unwrap_or_default(), - layers: layers__.unwrap_or_default(), - indication: indication__, + Ok(HypervisorDebugInfoRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageProgress", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.HypervisorDebugInfoRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageProgressIndication { +impl serde::Serialize for IdOrNameValue { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -7224,48 +7332,38 @@ impl serde::Serialize for OciImageProgressIndication { { use serde::ser::SerializeStruct; let mut len = 0; - if self.indication.is_some() { + if self.id_or_name.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndication", len)?; - if let Some(v) = self.indication.as_ref() { + let mut struct_ser = serializer.serialize_struct("protect.control.v1.IdOrNameValue", len)?; + if let Some(v) = self.id_or_name.as_ref() { match v { - oci_image_progress_indication::Indication::Bar(v) => { - struct_ser.serialize_field("bar", v)?; - } - oci_image_progress_indication::Indication::Spinner(v) => { - struct_ser.serialize_field("spinner", v)?; - } - oci_image_progress_indication::Indication::Hidden(v) => { - struct_ser.serialize_field("hidden", v)?; + id_or_name_value::IdOrName::Id(v) => { + struct_ser.serialize_field("id", v)?; } - oci_image_progress_indication::Indication::Completed(v) => { - struct_ser.serialize_field("completed", v)?; + id_or_name_value::IdOrName::Name(v) => { + struct_ser.serialize_field("name", v)?; } } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageProgressIndication { +impl<'de> serde::Deserialize<'de> for IdOrNameValue { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "bar", - "spinner", - "hidden", - "completed", + "id", + "name", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Bar, - Spinner, - Hidden, - Completed, + Id, + Name, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7287,10 +7385,8 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndication { E: serde::de::Error, { match value { - "bar" => Ok(GeneratedField::Bar), - "spinner" => Ok(GeneratedField::Spinner), - "hidden" => Ok(GeneratedField::Hidden), - "completed" => Ok(GeneratedField::Completed), + "id" => Ok(GeneratedField::Id), + "name" => Ok(GeneratedField::Name), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7300,58 +7396,42 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndication { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageProgressIndication; + type Value = IdOrNameValue; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageProgressIndication") + formatter.write_str("struct protect.control.v1.IdOrNameValue") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut indication__ = None; + let mut id_or_name__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Bar => { - if indication__.is_some() { - return Err(serde::de::Error::duplicate_field("bar")); - } - indication__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_image_progress_indication::Indication::Bar) -; - } - GeneratedField::Spinner => { - if indication__.is_some() { - return Err(serde::de::Error::duplicate_field("spinner")); - } - indication__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_image_progress_indication::Indication::Spinner) -; - } - GeneratedField::Hidden => { - if indication__.is_some() { - return Err(serde::de::Error::duplicate_field("hidden")); + GeneratedField::Id => { + if id_or_name__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); } - indication__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_image_progress_indication::Indication::Hidden) -; + id_or_name__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| id_or_name_value::IdOrName::Id(x.0)); } - GeneratedField::Completed => { - if indication__.is_some() { - return Err(serde::de::Error::duplicate_field("completed")); + GeneratedField::Name => { + if id_or_name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - indication__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_image_progress_indication::Indication::Completed) -; + id_or_name__ = map_.next_value::<::std::option::Option<_>>()?.map(id_or_name_value::IdOrName::Name); } } } - Ok(OciImageProgressIndication { - indication: indication__, + Ok(IdOrNameValue { + id_or_name: id_or_name__, }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndication", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.IdOrNameValue", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageProgressIndicationBar { +impl serde::Serialize for ImportImageReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -7359,58 +7439,53 @@ impl serde::Serialize for OciImageProgressIndicationBar { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.message.is_empty() { + if self.accepted { len += 1; } - if self.current != 0 { + if self.progress.is_some() { len += 1; } - if self.total != 0 { + if self.spec.is_some() { len += 1; } - if self.is_bytes { + if self.metadata.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndicationBar", len)?; - if !self.message.is_empty() { - struct_ser.serialize_field("message", &self.message)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ImportImageReply", len)?; + if self.accepted { + struct_ser.serialize_field("accepted", &self.accepted)?; } - if self.current != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("current", ToString::to_string(&self.current).as_str())?; + if let Some(v) = self.progress.as_ref() { + struct_ser.serialize_field("progress", v)?; } - if self.total != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("total", ToString::to_string(&self.total).as_str())?; + if let Some(v) = self.spec.as_ref() { + struct_ser.serialize_field("spec", v)?; } - if self.is_bytes { - struct_ser.serialize_field("isBytes", &self.is_bytes)?; + if let Some(v) = self.metadata.as_ref() { + struct_ser.serialize_field("metadata", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationBar { +impl<'de> serde::Deserialize<'de> for ImportImageReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "message", - "current", - "total", - "is_bytes", - "isBytes", + "accepted", + "progress", + "spec", + "metadata", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Message, - Current, - Total, - IsBytes, + Accepted, + Progress, + Spec, + Metadata, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7432,10 +7507,10 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationBar { E: serde::de::Error, { match value { - "message" => Ok(GeneratedField::Message), - "current" => Ok(GeneratedField::Current), - "total" => Ok(GeneratedField::Total), - "isBytes" | "is_bytes" => Ok(GeneratedField::IsBytes), + "accepted" => Ok(GeneratedField::Accepted), + "progress" => Ok(GeneratedField::Progress), + "spec" => Ok(GeneratedField::Spec), + "metadata" => Ok(GeneratedField::Metadata), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7445,64 +7520,60 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationBar { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageProgressIndicationBar; + type Value = ImportImageReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageProgressIndicationBar") + formatter.write_str("struct protect.control.v1.ImportImageReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut message__ = None; - let mut current__ = None; - let mut total__ = None; - let mut is_bytes__ = None; + let mut accepted__ = None; + let mut progress__ = None; + let mut spec__ = None; + let mut metadata__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Message => { - if message__.is_some() { - return Err(serde::de::Error::duplicate_field("message")); + GeneratedField::Accepted => { + if accepted__.is_some() { + return Err(serde::de::Error::duplicate_field("accepted")); } - message__ = Some(map_.next_value()?); + accepted__ = Some(map_.next_value()?); } - GeneratedField::Current => { - if current__.is_some() { - return Err(serde::de::Error::duplicate_field("current")); + GeneratedField::Progress => { + if progress__.is_some() { + return Err(serde::de::Error::duplicate_field("progress")); } - current__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + progress__ = map_.next_value()?; } - GeneratedField::Total => { - if total__.is_some() { - return Err(serde::de::Error::duplicate_field("total")); + GeneratedField::Spec => { + if spec__.is_some() { + return Err(serde::de::Error::duplicate_field("spec")); } - total__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + spec__ = map_.next_value()?; } - GeneratedField::IsBytes => { - if is_bytes__.is_some() { - return Err(serde::de::Error::duplicate_field("isBytes")); + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); } - is_bytes__ = Some(map_.next_value()?); + metadata__ = map_.next_value()?; } } } - Ok(OciImageProgressIndicationBar { - message: message__.unwrap_or_default(), - current: current__.unwrap_or_default(), - total: total__.unwrap_or_default(), - is_bytes: is_bytes__.unwrap_or_default(), + Ok(ImportImageReply { + accepted: accepted__.unwrap_or_default(), + progress: progress__, + spec: spec__, + metadata: metadata__, }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndicationBar", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ImportImageReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageProgressIndicationCompleted { +impl serde::Serialize for ImportImageRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -7510,50 +7581,104 @@ impl serde::Serialize for OciImageProgressIndicationCompleted { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.message.is_empty() { + if !self.digest.is_empty() { len += 1; } - if self.total != 0 { + if !self.image.is_empty() { len += 1; } - if self.is_bytes { + if self.format != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndicationCompleted", len)?; - if !self.message.is_empty() { - struct_ser.serialize_field("message", &self.message)?; + if !self.chunk.is_empty() { + len += 1; } - if self.total != 0 { + if self.last_chunk { + len += 1; + } + if self.overwrite_cache { + len += 1; + } + if self.want_metadata { + len += 1; + } + if !self.local_path.is_empty() { + len += 1; + } + if self.source_digest.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ImportImageRequest", len)?; + if !self.digest.is_empty() { + struct_ser.serialize_field("digest", &self.digest)?; + } + if !self.image.is_empty() { + struct_ser.serialize_field("image", &self.image)?; + } + if self.format != 0 { + let v = OciImageFormat::try_from(self.format) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; + struct_ser.serialize_field("format", &v)?; + } + if !self.chunk.is_empty() { #[allow(clippy::needless_borrow)] #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("total", ToString::to_string(&self.total).as_str())?; + struct_ser.serialize_field("chunk", pbjson::private::base64::encode(&self.chunk).as_str())?; } - if self.is_bytes { - struct_ser.serialize_field("isBytes", &self.is_bytes)?; + if self.last_chunk { + struct_ser.serialize_field("lastChunk", &self.last_chunk)?; + } + if self.overwrite_cache { + struct_ser.serialize_field("overwriteCache", &self.overwrite_cache)?; + } + if self.want_metadata { + struct_ser.serialize_field("wantMetadata", &self.want_metadata)?; + } + if !self.local_path.is_empty() { + struct_ser.serialize_field("localPath", &self.local_path)?; + } + if let Some(v) = self.source_digest.as_ref() { + struct_ser.serialize_field("sourceDigest", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationCompleted { +impl<'de> serde::Deserialize<'de> for ImportImageRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "message", - "total", - "is_bytes", - "isBytes", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Message, - Total, - IsBytes, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { + "digest", + "image", + "format", + "chunk", + "last_chunk", + "lastChunk", + "overwrite_cache", + "overwriteCache", + "want_metadata", + "wantMetadata", + "local_path", + "localPath", + "source_digest", + "sourceDigest", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Digest, + Image, + Format, + Chunk, + LastChunk, + OverwriteCache, + WantMetadata, + LocalPath, + SourceDigest, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, @@ -7573,9 +7698,15 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationCompleted { E: serde::de::Error, { match value { - "message" => Ok(GeneratedField::Message), - "total" => Ok(GeneratedField::Total), - "isBytes" | "is_bytes" => Ok(GeneratedField::IsBytes), + "digest" => Ok(GeneratedField::Digest), + "image" => Ok(GeneratedField::Image), + "format" => Ok(GeneratedField::Format), + "chunk" => Ok(GeneratedField::Chunk), + "lastChunk" | "last_chunk" => Ok(GeneratedField::LastChunk), + "overwriteCache" | "overwrite_cache" => Ok(GeneratedField::OverwriteCache), + "wantMetadata" | "want_metadata" => Ok(GeneratedField::WantMetadata), + "localPath" | "local_path" => Ok(GeneratedField::LocalPath), + "sourceDigest" | "source_digest" => Ok(GeneratedField::SourceDigest), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7585,76 +7716,132 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationCompleted { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageProgressIndicationCompleted; + type Value = ImportImageRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageProgressIndicationCompleted") + formatter.write_str("struct protect.control.v1.ImportImageRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut message__ = None; - let mut total__ = None; - let mut is_bytes__ = None; + let mut digest__ = None; + let mut image__ = None; + let mut format__ = None; + let mut chunk__ = None; + let mut last_chunk__ = None; + let mut overwrite_cache__ = None; + let mut want_metadata__ = None; + let mut local_path__ = None; + let mut source_digest__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Message => { - if message__.is_some() { - return Err(serde::de::Error::duplicate_field("message")); + GeneratedField::Digest => { + if digest__.is_some() { + return Err(serde::de::Error::duplicate_field("digest")); } - message__ = Some(map_.next_value()?); + digest__ = Some(map_.next_value()?); } - GeneratedField::Total => { - if total__.is_some() { - return Err(serde::de::Error::duplicate_field("total")); + GeneratedField::Image => { + if image__.is_some() { + return Err(serde::de::Error::duplicate_field("image")); } - total__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + image__ = Some(map_.next_value()?); + } + GeneratedField::Format => { + if format__.is_some() { + return Err(serde::de::Error::duplicate_field("format")); + } + format__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Chunk => { + if chunk__.is_some() { + return Err(serde::de::Error::duplicate_field("chunk")); + } + chunk__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } - GeneratedField::IsBytes => { - if is_bytes__.is_some() { - return Err(serde::de::Error::duplicate_field("isBytes")); + GeneratedField::LastChunk => { + if last_chunk__.is_some() { + return Err(serde::de::Error::duplicate_field("lastChunk")); } - is_bytes__ = Some(map_.next_value()?); + last_chunk__ = Some(map_.next_value()?); + } + GeneratedField::OverwriteCache => { + if overwrite_cache__.is_some() { + return Err(serde::de::Error::duplicate_field("overwriteCache")); + } + overwrite_cache__ = Some(map_.next_value()?); + } + GeneratedField::WantMetadata => { + if want_metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("wantMetadata")); + } + want_metadata__ = Some(map_.next_value()?); + } + GeneratedField::LocalPath => { + if local_path__.is_some() { + return Err(serde::de::Error::duplicate_field("localPath")); + } + local_path__ = Some(map_.next_value()?); + } + GeneratedField::SourceDigest => { + if source_digest__.is_some() { + return Err(serde::de::Error::duplicate_field("sourceDigest")); + } + source_digest__ = map_.next_value()?; } } } - Ok(OciImageProgressIndicationCompleted { - message: message__.unwrap_or_default(), - total: total__.unwrap_or_default(), - is_bytes: is_bytes__.unwrap_or_default(), + Ok(ImportImageRequest { + digest: digest__.unwrap_or_default(), + image: image__.unwrap_or_default(), + format: format__.unwrap_or_default(), + chunk: chunk__.unwrap_or_default(), + last_chunk: last_chunk__.unwrap_or_default(), + overwrite_cache: overwrite_cache__.unwrap_or_default(), + want_metadata: want_metadata__.unwrap_or_default(), + local_path: local_path__.unwrap_or_default(), + source_digest: source_digest__, }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndicationCompleted", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ImportImageRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageProgressIndicationHidden { +impl serde::Serialize for ImportPackedImageReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndicationHidden", len)?; + let mut len = 0; + if self.spec.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ImportPackedImageReply", len)?; + if let Some(v) = self.spec.as_ref() { + struct_ser.serialize_field("spec", v)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationHidden { +impl<'de> serde::Deserialize<'de> for ImportPackedImageReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "spec", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Spec, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7675,7 +7862,10 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationHidden { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "spec" => Ok(GeneratedField::Spec), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -7683,27 +7873,36 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationHidden { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageProgressIndicationHidden; + type Value = ImportPackedImageReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageProgressIndicationHidden") + formatter.write_str("struct protect.control.v1.ImportPackedImageReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut spec__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Spec => { + if spec__.is_some() { + return Err(serde::de::Error::duplicate_field("spec")); + } + spec__ = map_.next_value()?; + } + } } - Ok(OciImageProgressIndicationHidden { + Ok(ImportPackedImageReply { + spec: spec__, }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndicationHidden", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ImportPackedImageReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageProgressIndicationSpinner { +impl serde::Serialize for ImportPackedImageRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -7711,29 +7910,113 @@ impl serde::Serialize for OciImageProgressIndicationSpinner { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.message.is_empty() { + if !self.image.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndicationSpinner", len)?; - if !self.message.is_empty() { - struct_ser.serialize_field("message", &self.message)?; + if !self.digest.is_empty() { + len += 1; + } + if self.format != 0 { + len += 1; + } + if !self.manifest.is_empty() { + len += 1; + } + if !self.config.is_empty() { + len += 1; + } + if !self.chunk.is_empty() { + len += 1; + } + if self.last_chunk { + len += 1; + } + if !self.local_path.is_empty() { + len += 1; + } + if self.overwrite_cache { + len += 1; + } + if self.linked_blob.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ImportPackedImageRequest", len)?; + if !self.image.is_empty() { + struct_ser.serialize_field("image", &self.image)?; + } + if !self.digest.is_empty() { + struct_ser.serialize_field("digest", &self.digest)?; + } + if self.format != 0 { + let v = OciImageFormat::try_from(self.format) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; + struct_ser.serialize_field("format", &v)?; + } + if !self.manifest.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("manifest", pbjson::private::base64::encode(&self.manifest).as_str())?; + } + if !self.config.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("config", pbjson::private::base64::encode(&self.config).as_str())?; + } + if !self.chunk.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("chunk", pbjson::private::base64::encode(&self.chunk).as_str())?; + } + if self.last_chunk { + struct_ser.serialize_field("lastChunk", &self.last_chunk)?; + } + if !self.local_path.is_empty() { + struct_ser.serialize_field("localPath", &self.local_path)?; + } + if self.overwrite_cache { + struct_ser.serialize_field("overwriteCache", &self.overwrite_cache)?; + } + if let Some(v) = self.linked_blob.as_ref() { + struct_ser.serialize_field("linkedBlob", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationSpinner { +impl<'de> serde::Deserialize<'de> for ImportPackedImageRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "message", + "image", + "digest", + "format", + "manifest", + "config", + "chunk", + "last_chunk", + "lastChunk", + "local_path", + "localPath", + "overwrite_cache", + "overwriteCache", + "linked_blob", + "linkedBlob", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Message, + Image, + Digest, + Format, + Manifest, + Config, + Chunk, + LastChunk, + LocalPath, + OverwriteCache, + LinkedBlob, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7755,7 +8038,16 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationSpinner { E: serde::de::Error, { match value { - "message" => Ok(GeneratedField::Message), + "image" => Ok(GeneratedField::Image), + "digest" => Ok(GeneratedField::Digest), + "format" => Ok(GeneratedField::Format), + "manifest" => Ok(GeneratedField::Manifest), + "config" => Ok(GeneratedField::Config), + "chunk" => Ok(GeneratedField::Chunk), + "lastChunk" | "last_chunk" => Ok(GeneratedField::LastChunk), + "localPath" | "local_path" => Ok(GeneratedField::LocalPath), + "overwriteCache" | "overwrite_cache" => Ok(GeneratedField::OverwriteCache), + "linkedBlob" | "linked_blob" => Ok(GeneratedField::LinkedBlob), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7765,36 +8057,114 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationSpinner { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageProgressIndicationSpinner; + type Value = ImportPackedImageRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageProgressIndicationSpinner") + formatter.write_str("struct protect.control.v1.ImportPackedImageRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut message__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Message => { - if message__.is_some() { - return Err(serde::de::Error::duplicate_field("message")); + let mut image__ = None; + let mut digest__ = None; + let mut format__ = None; + let mut manifest__ = None; + let mut config__ = None; + let mut chunk__ = None; + let mut last_chunk__ = None; + let mut local_path__ = None; + let mut overwrite_cache__ = None; + let mut linked_blob__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Image => { + if image__.is_some() { + return Err(serde::de::Error::duplicate_field("image")); } - message__ = Some(map_.next_value()?); + image__ = Some(map_.next_value()?); + } + GeneratedField::Digest => { + if digest__.is_some() { + return Err(serde::de::Error::duplicate_field("digest")); + } + digest__ = Some(map_.next_value()?); + } + GeneratedField::Format => { + if format__.is_some() { + return Err(serde::de::Error::duplicate_field("format")); + } + format__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Manifest => { + if manifest__.is_some() { + return Err(serde::de::Error::duplicate_field("manifest")); + } + manifest__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Config => { + if config__.is_some() { + return Err(serde::de::Error::duplicate_field("config")); + } + config__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Chunk => { + if chunk__.is_some() { + return Err(serde::de::Error::duplicate_field("chunk")); + } + chunk__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::LastChunk => { + if last_chunk__.is_some() { + return Err(serde::de::Error::duplicate_field("lastChunk")); + } + last_chunk__ = Some(map_.next_value()?); + } + GeneratedField::LocalPath => { + if local_path__.is_some() { + return Err(serde::de::Error::duplicate_field("localPath")); + } + local_path__ = Some(map_.next_value()?); + } + GeneratedField::OverwriteCache => { + if overwrite_cache__.is_some() { + return Err(serde::de::Error::duplicate_field("overwriteCache")); + } + overwrite_cache__ = Some(map_.next_value()?); + } + GeneratedField::LinkedBlob => { + if linked_blob__.is_some() { + return Err(serde::de::Error::duplicate_field("linkedBlob")); + } + linked_blob__ = map_.next_value()?; } } } - Ok(OciImageProgressIndicationSpinner { - message: message__.unwrap_or_default(), + Ok(ImportPackedImageRequest { + image: image__.unwrap_or_default(), + digest: digest__.unwrap_or_default(), + format: format__.unwrap_or_default(), + manifest: manifest__.unwrap_or_default(), + config: config__.unwrap_or_default(), + chunk: chunk__.unwrap_or_default(), + last_chunk: last_chunk__.unwrap_or_default(), + local_path: local_path__.unwrap_or_default(), + overwrite_cache: overwrite_cache__.unwrap_or_default(), + linked_blob: linked_blob__, }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndicationSpinner", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ImportPackedImageRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageProgressLayer { +impl serde::Serialize for ImportZoneReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -7802,47 +8172,30 @@ impl serde::Serialize for OciImageProgressLayer { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.id.is_empty() { - len += 1; - } - if self.phase != 0 { - len += 1; - } - if self.indication.is_some() { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressLayer", len)?; - if !self.id.is_empty() { - struct_ser.serialize_field("id", &self.id)?; - } - if self.phase != 0 { - let v = OciImageProgressLayerPhase::try_from(self.phase) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.phase)))?; - struct_ser.serialize_field("phase", &v)?; - } - if let Some(v) = self.indication.as_ref() { - struct_ser.serialize_field("indication", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ImportZoneReply", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageProgressLayer { +impl<'de> serde::Deserialize<'de> for ImportZoneReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "id", - "phase", - "indication", + "zone_id", + "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Id, - Phase, - Indication, + ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7864,9 +8217,7 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressLayer { E: serde::de::Error, { match value { - "id" => Ok(GeneratedField::Id), - "phase" => Ok(GeneratedField::Phase), - "indication" => Ok(GeneratedField::Indication), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7876,227 +8227,146 @@ impl<'de> serde::Deserialize<'de> for OciImageProgressLayer { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageProgressLayer; + type Value = ImportZoneReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageProgressLayer") + formatter.write_str("struct protect.control.v1.ImportZoneReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut id__ = None; - let mut phase__ = None; - let mut indication__ = None; + let mut zone_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Id => { - if id__.is_some() { - return Err(serde::de::Error::duplicate_field("id")); - } - id__ = Some(map_.next_value()?); - } - GeneratedField::Phase => { - if phase__.is_some() { - return Err(serde::de::Error::duplicate_field("phase")); - } - phase__ = Some(map_.next_value::()? as i32); - } - GeneratedField::Indication => { - if indication__.is_some() { - return Err(serde::de::Error::duplicate_field("indication")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - indication__ = map_.next_value()?; + zone_id__ = Some(map_.next_value()?); } } } - Ok(OciImageProgressLayer { - id: id__.unwrap_or_default(), - phase: phase__.unwrap_or_default(), - indication: indication__, + Ok(ImportZoneReply { + zone_id: zone_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageProgressLayer", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ImportZoneReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageProgressLayerPhase { +impl serde::Serialize for ImportZoneRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Unknown => "OCI_IMAGE_PROGRESS_LAYER_PHASE_UNKNOWN", - Self::Waiting => "OCI_IMAGE_PROGRESS_LAYER_PHASE_WAITING", - Self::Downloading => "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADING", - Self::Downloaded => "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADED", - Self::Extracting => "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTING", - Self::Extracted => "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTED", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if self.request.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ImportZoneRequest", len)?; + if let Some(v) = self.request.as_ref() { + match v { + import_zone_request::Request::Start(v) => { + struct_ser.serialize_field("start", v)?; + } + import_zone_request::Request::Chunk(v) => { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("chunk", pbjson::private::base64::encode(&v).as_str())?; + } + } + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageProgressLayerPhase { +impl<'de> serde::Deserialize<'de> for ImportZoneRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "OCI_IMAGE_PROGRESS_LAYER_PHASE_UNKNOWN", - "OCI_IMAGE_PROGRESS_LAYER_PHASE_WAITING", - "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADING", - "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADED", - "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTING", - "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTED", + "start", + "chunk", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Start, + Chunk, + } + 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 = OciImageProgressLayerPhase; + 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) - } + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "start" => Ok(GeneratedField::Start), + "chunk" => Ok(GeneratedField::Chunk), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ImportZoneRequest; - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ImportZoneRequest") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "OCI_IMAGE_PROGRESS_LAYER_PHASE_UNKNOWN" => Ok(OciImageProgressLayerPhase::Unknown), - "OCI_IMAGE_PROGRESS_LAYER_PHASE_WAITING" => Ok(OciImageProgressLayerPhase::Waiting), - "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADING" => Ok(OciImageProgressLayerPhase::Downloading), - "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADED" => Ok(OciImageProgressLayerPhase::Downloaded), - "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTING" => Ok(OciImageProgressLayerPhase::Extracting), - "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTED" => Ok(OciImageProgressLayerPhase::Extracted), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for OciImageProgressPhase { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Unknown => "OCI_IMAGE_PROGRESS_PHASE_UNKNOWN", - Self::Started => "OCI_IMAGE_PROGRESS_PHASE_STARTED", - Self::Resolving => "OCI_IMAGE_PROGRESS_PHASE_RESOLVING", - Self::Resolved => "OCI_IMAGE_PROGRESS_PHASE_RESOLVED", - Self::ConfigDownload => "OCI_IMAGE_PROGRESS_PHASE_CONFIG_DOWNLOAD", - Self::LayerDownload => "OCI_IMAGE_PROGRESS_PHASE_LAYER_DOWNLOAD", - Self::Assemble => "OCI_IMAGE_PROGRESS_PHASE_ASSEMBLE", - Self::Pack => "OCI_IMAGE_PROGRESS_PHASE_PACK", - Self::Complete => "OCI_IMAGE_PROGRESS_PHASE_COMPLETE", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for OciImageProgressPhase { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "OCI_IMAGE_PROGRESS_PHASE_UNKNOWN", - "OCI_IMAGE_PROGRESS_PHASE_STARTED", - "OCI_IMAGE_PROGRESS_PHASE_RESOLVING", - "OCI_IMAGE_PROGRESS_PHASE_RESOLVED", - "OCI_IMAGE_PROGRESS_PHASE_CONFIG_DOWNLOAD", - "OCI_IMAGE_PROGRESS_PHASE_LAYER_DOWNLOAD", - "OCI_IMAGE_PROGRESS_PHASE_ASSEMBLE", - "OCI_IMAGE_PROGRESS_PHASE_PACK", - "OCI_IMAGE_PROGRESS_PHASE_COMPLETE", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageProgressPhase; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "OCI_IMAGE_PROGRESS_PHASE_UNKNOWN" => Ok(OciImageProgressPhase::Unknown), - "OCI_IMAGE_PROGRESS_PHASE_STARTED" => Ok(OciImageProgressPhase::Started), - "OCI_IMAGE_PROGRESS_PHASE_RESOLVING" => Ok(OciImageProgressPhase::Resolving), - "OCI_IMAGE_PROGRESS_PHASE_RESOLVED" => Ok(OciImageProgressPhase::Resolved), - "OCI_IMAGE_PROGRESS_PHASE_CONFIG_DOWNLOAD" => Ok(OciImageProgressPhase::ConfigDownload), - "OCI_IMAGE_PROGRESS_PHASE_LAYER_DOWNLOAD" => Ok(OciImageProgressPhase::LayerDownload), - "OCI_IMAGE_PROGRESS_PHASE_ASSEMBLE" => Ok(OciImageProgressPhase::Assemble), - "OCI_IMAGE_PROGRESS_PHASE_PACK" => Ok(OciImageProgressPhase::Pack), - "OCI_IMAGE_PROGRESS_PHASE_COMPLETE" => Ok(OciImageProgressPhase::Complete), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut request__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Start => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("start")); + } + request__ = map_.next_value::<::std::option::Option<_>>()?.map(import_zone_request::Request::Start) +; + } + GeneratedField::Chunk => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("chunk")); + } + request__ = map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| import_zone_request::Request::Chunk(x.0)); + } + } } + Ok(ImportZoneRequest { + request: request__, + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ImportZoneRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciImageSpec { +impl serde::Serialize for ImportZoneStart { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8104,39 +8374,46 @@ impl serde::Serialize for OciImageSpec { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.digest.is_empty() { + if !self.name.is_empty() { len += 1; } - if self.format != 0 { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageSpec", len)?; - if !self.digest.is_empty() { - struct_ser.serialize_field("digest", &self.digest)?; + if self.restore.is_some() { + len += 1; } - if self.format != 0 { - let v = OciImageFormat::try_from(self.format) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; - struct_ser.serialize_field("format", &v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ImportZoneStart", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if let Some(v) = self.restore.as_ref() { + struct_ser.serialize_field("restore", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciImageSpec { +impl<'de> serde::Deserialize<'de> for ImportZoneStart { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "digest", - "format", + "name", + "zone_id", + "zoneId", + "restore", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Digest, - Format, + Name, + ZoneId, + Restore, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8158,8 +8435,9 @@ impl<'de> serde::Deserialize<'de> for OciImageSpec { E: serde::de::Error, { match value { - "digest" => Ok(GeneratedField::Digest), - "format" => Ok(GeneratedField::Format), + "name" => Ok(GeneratedField::Name), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "restore" => Ok(GeneratedField::Restore), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8169,44 +8447,52 @@ impl<'de> serde::Deserialize<'de> for OciImageSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciImageSpec; + type Value = ImportZoneStart; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciImageSpec") + formatter.write_str("struct protect.control.v1.ImportZoneStart") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut digest__ = None; - let mut format__ = None; + let mut name__ = None; + let mut zone_id__ = None; + let mut restore__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Digest => { - if digest__.is_some() { - return Err(serde::de::Error::duplicate_field("digest")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - digest__ = Some(map_.next_value()?); + name__ = Some(map_.next_value()?); } - GeneratedField::Format => { - if format__.is_some() { - return Err(serde::de::Error::duplicate_field("format")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - format__ = Some(map_.next_value::()? as i32); + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Restore => { + if restore__.is_some() { + return Err(serde::de::Error::duplicate_field("restore")); + } + restore__ = map_.next_value()?; } } } - Ok(OciImageSpec { - digest: digest__.unwrap_or_default(), - format: format__.unwrap_or_default(), + Ok(ImportZoneStart { + name: name__.unwrap_or_default(), + zone_id: zone_id__.unwrap_or_default(), + restore: restore__, }) } } - deserializer.deserialize_struct("protect.control.v1.OciImageSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ImportZoneStart", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciRegistryAuthentication { +impl serde::Serialize for KernelModuleParameter { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8214,52 +8500,37 @@ impl serde::Serialize for OciRegistryAuthentication { { use serde::ser::SerializeStruct; let mut len = 0; - if self.authentication_method.is_some() { + if !self.module.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciRegistryAuthentication", len)?; - if let Some(v) = self.authentication_method.as_ref() { - match v { - oci_registry_authentication::AuthenticationMethod::UsernamePassword(v) => { - struct_ser.serialize_field("usernamePassword", v)?; - } - oci_registry_authentication::AuthenticationMethod::RawBasicAuth(v) => { - struct_ser.serialize_field("rawBasicAuth", v)?; - } - oci_registry_authentication::AuthenticationMethod::IdentityToken(v) => { - struct_ser.serialize_field("identityToken", v)?; - } - oci_registry_authentication::AuthenticationMethod::RegistryToken(v) => { - struct_ser.serialize_field("registryToken", v)?; - } - } + if !self.parameter.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.KernelModuleParameter", len)?; + if !self.module.is_empty() { + struct_ser.serialize_field("module", &self.module)?; + } + if !self.parameter.is_empty() { + struct_ser.serialize_field("parameter", &self.parameter)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciRegistryAuthentication { +impl<'de> serde::Deserialize<'de> for KernelModuleParameter { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "username_password", - "usernamePassword", - "raw_basic_auth", - "rawBasicAuth", - "identity_token", - "identityToken", - "registry_token", - "registryToken", + "module", + "parameter", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - UsernamePassword, - RawBasicAuth, - IdentityToken, - RegistryToken, + Module, + Parameter, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8281,10 +8552,8 @@ impl<'de> serde::Deserialize<'de> for OciRegistryAuthentication { E: serde::de::Error, { match value { - "usernamePassword" | "username_password" => Ok(GeneratedField::UsernamePassword), - "rawBasicAuth" | "raw_basic_auth" => Ok(GeneratedField::RawBasicAuth), - "identityToken" | "identity_token" => Ok(GeneratedField::IdentityToken), - "registryToken" | "registry_token" => Ok(GeneratedField::RegistryToken), + "module" => Ok(GeneratedField::Module), + "parameter" => Ok(GeneratedField::Parameter), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8294,55 +8563,44 @@ impl<'de> serde::Deserialize<'de> for OciRegistryAuthentication { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciRegistryAuthentication; + type Value = KernelModuleParameter; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciRegistryAuthentication") + formatter.write_str("struct protect.control.v1.KernelModuleParameter") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut authentication_method__ = None; + let mut module__ = None; + let mut parameter__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::UsernamePassword => { - if authentication_method__.is_some() { - return Err(serde::de::Error::duplicate_field("usernamePassword")); - } - authentication_method__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_registry_authentication::AuthenticationMethod::UsernamePassword) -; - } - GeneratedField::RawBasicAuth => { - if authentication_method__.is_some() { - return Err(serde::de::Error::duplicate_field("rawBasicAuth")); + GeneratedField::Module => { + if module__.is_some() { + return Err(serde::de::Error::duplicate_field("module")); } - authentication_method__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_registry_authentication::AuthenticationMethod::RawBasicAuth); + module__ = Some(map_.next_value()?); } - GeneratedField::IdentityToken => { - if authentication_method__.is_some() { - return Err(serde::de::Error::duplicate_field("identityToken")); + GeneratedField::Parameter => { + if parameter__.is_some() { + return Err(serde::de::Error::duplicate_field("parameter")); } - authentication_method__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_registry_authentication::AuthenticationMethod::IdentityToken); - } - GeneratedField::RegistryToken => { - if authentication_method__.is_some() { - return Err(serde::de::Error::duplicate_field("registryToken")); - } - authentication_method__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_registry_authentication::AuthenticationMethod::RegistryToken); + parameter__ = Some(map_.next_value()?); } } } - Ok(OciRegistryAuthentication { - authentication_method: authentication_method__, + Ok(KernelModuleParameter { + module: module__.unwrap_or_default(), + parameter: parameter__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.OciRegistryAuthentication", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.KernelModuleParameter", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OciRegistryUsernamePassword { +impl serde::Serialize for KernelOptionsSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8350,37 +8608,72 @@ impl serde::Serialize for OciRegistryUsernamePassword { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.username.is_empty() { + if self.verbose { len += 1; } - if !self.password.is_empty() { + if !self.cmdline_append.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciRegistryUsernamePassword", len)?; - if !self.username.is_empty() { - struct_ser.serialize_field("username", &self.username)?; + if !self.cmdline.is_empty() { + len += 1; } - if !self.password.is_empty() { - struct_ser.serialize_field("password", &self.password)?; + if !self.modules.is_empty() { + len += 1; + } + if !self.module_parameters.is_empty() { + len += 1; + } + if !self.sysctl_parameters.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.KernelOptionsSpec", len)?; + if self.verbose { + struct_ser.serialize_field("verbose", &self.verbose)?; + } + if !self.cmdline_append.is_empty() { + struct_ser.serialize_field("cmdlineAppend", &self.cmdline_append)?; + } + if !self.cmdline.is_empty() { + struct_ser.serialize_field("cmdline", &self.cmdline)?; + } + if !self.modules.is_empty() { + struct_ser.serialize_field("modules", &self.modules)?; + } + if !self.module_parameters.is_empty() { + struct_ser.serialize_field("moduleParameters", &self.module_parameters)?; + } + if !self.sysctl_parameters.is_empty() { + struct_ser.serialize_field("sysctlParameters", &self.sysctl_parameters)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OciRegistryUsernamePassword { +impl<'de> serde::Deserialize<'de> for KernelOptionsSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "username", - "password", + "verbose", + "cmdline_append", + "cmdlineAppend", + "cmdline", + "modules", + "module_parameters", + "moduleParameters", + "sysctl_parameters", + "sysctlParameters", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Username, - Password, + Verbose, + CmdlineAppend, + Cmdline, + Modules, + ModuleParameters, + SysctlParameters, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8402,8 +8695,12 @@ impl<'de> serde::Deserialize<'de> for OciRegistryUsernamePassword { E: serde::de::Error, { match value { - "username" => Ok(GeneratedField::Username), - "password" => Ok(GeneratedField::Password), + "verbose" => Ok(GeneratedField::Verbose), + "cmdlineAppend" | "cmdline_append" => Ok(GeneratedField::CmdlineAppend), + "cmdline" => Ok(GeneratedField::Cmdline), + "modules" => Ok(GeneratedField::Modules), + "moduleParameters" | "module_parameters" => Ok(GeneratedField::ModuleParameters), + "sysctlParameters" | "sysctl_parameters" => Ok(GeneratedField::SysctlParameters), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8413,133 +8710,184 @@ impl<'de> serde::Deserialize<'de> for OciRegistryUsernamePassword { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OciRegistryUsernamePassword; + type Value = KernelOptionsSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.OciRegistryUsernamePassword") + formatter.write_str("struct protect.control.v1.KernelOptionsSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut username__ = None; - let mut password__ = None; + let mut verbose__ = None; + let mut cmdline_append__ = None; + let mut cmdline__ = None; + let mut modules__ = None; + let mut module_parameters__ = None; + let mut sysctl_parameters__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Username => { - if username__.is_some() { - return Err(serde::de::Error::duplicate_field("username")); + GeneratedField::Verbose => { + if verbose__.is_some() { + return Err(serde::de::Error::duplicate_field("verbose")); } - username__ = Some(map_.next_value()?); + verbose__ = Some(map_.next_value()?); } - GeneratedField::Password => { - if password__.is_some() { - return Err(serde::de::Error::duplicate_field("password")); + GeneratedField::CmdlineAppend => { + if cmdline_append__.is_some() { + return Err(serde::de::Error::duplicate_field("cmdlineAppend")); } - password__ = Some(map_.next_value()?); + cmdline_append__ = Some(map_.next_value()?); + } + GeneratedField::Cmdline => { + if cmdline__.is_some() { + return Err(serde::de::Error::duplicate_field("cmdline")); + } + cmdline__ = Some(map_.next_value()?); + } + GeneratedField::Modules => { + if modules__.is_some() { + return Err(serde::de::Error::duplicate_field("modules")); + } + modules__ = Some(map_.next_value()?); + } + GeneratedField::ModuleParameters => { + if module_parameters__.is_some() { + return Err(serde::de::Error::duplicate_field("moduleParameters")); + } + module_parameters__ = Some(map_.next_value()?); + } + GeneratedField::SysctlParameters => { + if sysctl_parameters__.is_some() { + return Err(serde::de::Error::duplicate_field("sysctlParameters")); + } + sysctl_parameters__ = Some(map_.next_value()?); } } } - Ok(OciRegistryUsernamePassword { - username: username__.unwrap_or_default(), - password: password__.unwrap_or_default(), + Ok(KernelOptionsSpec { + verbose: verbose__.unwrap_or_default(), + cmdline_append: cmdline_append__.unwrap_or_default(), + cmdline: cmdline__.unwrap_or_default(), + modules: modules__.unwrap_or_default(), + module_parameters: module_parameters__.unwrap_or_default(), + sysctl_parameters: sysctl_parameters__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.OciRegistryUsernamePassword", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.KernelOptionsSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ProcessNamespace { +impl serde::Serialize for KernelSysctlParameter { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Mount => "PROCESS_NAMESPACE_MOUNT", - Self::Uts => "PROCESS_NAMESPACE_UTS", - Self::Ipc => "PROCESS_NAMESPACE_IPC", - Self::User => "PROCESS_NAMESPACE_USER", - Self::Pid => "PROCESS_NAMESPACE_PID", - Self::Net => "PROCESS_NAMESPACE_NET", - Self::Cgroup => "PROCESS_NAMESPACE_CGROUP", - Self::Time => "PROCESS_NAMESPACE_TIME", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key.is_empty() { + len += 1; + } + if !self.value.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.KernelSysctlParameter", len)?; + if !self.key.is_empty() { + struct_ser.serialize_field("key", &self.key)?; + } + if !self.value.is_empty() { + struct_ser.serialize_field("value", &self.value)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ProcessNamespace { +impl<'de> serde::Deserialize<'de> for KernelSysctlParameter { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "PROCESS_NAMESPACE_MOUNT", - "PROCESS_NAMESPACE_UTS", - "PROCESS_NAMESPACE_IPC", - "PROCESS_NAMESPACE_USER", - "PROCESS_NAMESPACE_PID", - "PROCESS_NAMESPACE_NET", - "PROCESS_NAMESPACE_CGROUP", - "PROCESS_NAMESPACE_TIME", + "key", + "value", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Key, + Value, + } + 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 = ProcessNamespace; + 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) - } + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "key" => Ok(GeneratedField::Key), + "value" => Ok(GeneratedField::Value), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = KernelSysctlParameter; - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.KernelSysctlParameter") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "PROCESS_NAMESPACE_MOUNT" => Ok(ProcessNamespace::Mount), - "PROCESS_NAMESPACE_UTS" => Ok(ProcessNamespace::Uts), - "PROCESS_NAMESPACE_IPC" => Ok(ProcessNamespace::Ipc), - "PROCESS_NAMESPACE_USER" => Ok(ProcessNamespace::User), - "PROCESS_NAMESPACE_PID" => Ok(ProcessNamespace::Pid), - "PROCESS_NAMESPACE_NET" => Ok(ProcessNamespace::Net), - "PROCESS_NAMESPACE_CGROUP" => Ok(ProcessNamespace::Cgroup), - "PROCESS_NAMESPACE_TIME" => Ok(ProcessNamespace::Time), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut key__ = None; + let mut value__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); + } + key__ = Some(map_.next_value()?); + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = Some(map_.next_value()?); + } + } } + Ok(KernelSysctlParameter { + key: key__.unwrap_or_default(), + value: value__.unwrap_or_default(), + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.KernelSysctlParameter", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ProcessSpec { +impl serde::Serialize for KernelVariant { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8547,112 +8895,37 @@ impl serde::Serialize for ProcessSpec { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.environment.is_empty() { - len += 1; - } - if !self.command.is_empty() { - len += 1; - } - if !self.working_directory.is_empty() { - len += 1; - } - if self.tty { - len += 1; - } - if self.terminal_size.is_some() { - len += 1; - } - if self.user.is_some() { - len += 1; - } - if self.group.is_some() { - len += 1; - } - if self.stdin { - len += 1; - } - if self.stdout { - len += 1; - } - if self.stderr { + if !self.name.is_empty() { len += 1; } - if !self.additional_gids.is_empty() { + if !self.image.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)?; - } - if !self.command.is_empty() { - struct_ser.serialize_field("command", &self.command)?; - } - if !self.working_directory.is_empty() { - struct_ser.serialize_field("workingDirectory", &self.working_directory)?; - } - if self.tty { - struct_ser.serialize_field("tty", &self.tty)?; - } - if let Some(v) = self.terminal_size.as_ref() { - struct_ser.serialize_field("terminalSize", v)?; - } - if let Some(v) = self.user.as_ref() { - struct_ser.serialize_field("user", v)?; - } - if let Some(v) = self.group.as_ref() { - struct_ser.serialize_field("group", v)?; - } - if self.stdin { - struct_ser.serialize_field("stdin", &self.stdin)?; - } - if self.stdout { - struct_ser.serialize_field("stdout", &self.stdout)?; - } - if self.stderr { - struct_ser.serialize_field("stderr", &self.stderr)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.KernelVariant", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; } - if !self.additional_gids.is_empty() { - struct_ser.serialize_field("additionalGids", &self.additional_gids.iter().map(ToString::to_string).collect::>())?; + if !self.image.is_empty() { + struct_ser.serialize_field("image", &self.image)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ProcessSpec { +impl<'de> serde::Deserialize<'de> for KernelVariant { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "environment", - "command", - "working_directory", - "workingDirectory", - "tty", - "terminal_size", - "terminalSize", - "user", - "group", - "stdin", - "stdout", - "stderr", - "additional_gids", - "additionalGids", + "name", + "image", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Environment, - Command, - WorkingDirectory, - Tty, - TerminalSize, - User, - Group, - Stdin, - Stdout, - Stderr, - AdditionalGids, + Name, + Image, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8674,17 +8947,8 @@ impl<'de> serde::Deserialize<'de> for ProcessSpec { E: serde::de::Error, { match value { - "environment" => Ok(GeneratedField::Environment), - "command" => Ok(GeneratedField::Command), - "workingDirectory" | "working_directory" => Ok(GeneratedField::WorkingDirectory), - "tty" => Ok(GeneratedField::Tty), - "terminalSize" | "terminal_size" => Ok(GeneratedField::TerminalSize), - "user" => Ok(GeneratedField::User), - "group" => Ok(GeneratedField::Group), - "stdin" => Ok(GeneratedField::Stdin), - "stdout" => Ok(GeneratedField::Stdout), - "stderr" => Ok(GeneratedField::Stderr), - "additionalGids" | "additional_gids" => Ok(GeneratedField::AdditionalGids), + "name" => Ok(GeneratedField::Name), + "image" => Ok(GeneratedField::Image), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8694,119 +8958,44 @@ impl<'de> serde::Deserialize<'de> for ProcessSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ProcessSpec; + type Value = KernelVariant; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ProcessSpec") + formatter.write_str("struct protect.control.v1.KernelVariant") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut environment__ = None; - let mut command__ = None; - let mut working_directory__ = None; - let mut tty__ = None; - let mut terminal_size__ = None; - let mut user__ = None; - let mut group__ = None; - let mut stdin__ = None; - let mut stdout__ = None; - let mut stderr__ = None; - let mut additional_gids__ = None; + let mut name__ = None; + let mut image__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Environment => { - if environment__.is_some() { - return Err(serde::de::Error::duplicate_field("environment")); - } - environment__ = Some(map_.next_value()?); - } - GeneratedField::Command => { - if command__.is_some() { - return Err(serde::de::Error::duplicate_field("command")); - } - command__ = Some(map_.next_value()?); - } - GeneratedField::WorkingDirectory => { - if working_directory__.is_some() { - return Err(serde::de::Error::duplicate_field("workingDirectory")); - } - working_directory__ = Some(map_.next_value()?); - } - GeneratedField::Tty => { - if tty__.is_some() { - return Err(serde::de::Error::duplicate_field("tty")); - } - tty__ = Some(map_.next_value()?); - } - GeneratedField::TerminalSize => { - if terminal_size__.is_some() { - return Err(serde::de::Error::duplicate_field("terminalSize")); - } - terminal_size__ = map_.next_value()?; - } - GeneratedField::User => { - if user__.is_some() { - return Err(serde::de::Error::duplicate_field("user")); - } - user__ = map_.next_value()?; - } - GeneratedField::Group => { - if group__.is_some() { - return Err(serde::de::Error::duplicate_field("group")); - } - group__ = map_.next_value()?; - } - GeneratedField::Stdin => { - if stdin__.is_some() { - return Err(serde::de::Error::duplicate_field("stdin")); - } - stdin__ = Some(map_.next_value()?); - } - GeneratedField::Stdout => { - if stdout__.is_some() { - return Err(serde::de::Error::duplicate_field("stdout")); - } - stdout__ = Some(map_.next_value()?); - } - GeneratedField::Stderr => { - if stderr__.is_some() { - return Err(serde::de::Error::duplicate_field("stderr")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - stderr__ = Some(map_.next_value()?); + name__ = Some(map_.next_value()?); } - GeneratedField::AdditionalGids => { - if additional_gids__.is_some() { - return Err(serde::de::Error::duplicate_field("additionalGids")); + GeneratedField::Image => { + if image__.is_some() { + return Err(serde::de::Error::duplicate_field("image")); } - additional_gids__ = - Some(map_.next_value::>>()? - .into_iter().map(|x| x.0).collect()) - ; + image__ = Some(map_.next_value()?); } } } - Ok(ProcessSpec { - environment: environment__.unwrap_or_default(), - command: command__.unwrap_or_default(), - working_directory: working_directory__.unwrap_or_default(), - tty: tty__.unwrap_or_default(), - terminal_size: terminal_size__, - user: user__, - group: group__, - stdin: stdin__.unwrap_or_default(), - stdout: stdout__.unwrap_or_default(), - stderr: stderr__.unwrap_or_default(), - additional_gids: additional_gids__.unwrap_or_default(), + Ok(KernelVariant { + name: name__.unwrap_or_default(), + image: image__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ProcessSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.KernelVariant", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for PullImageReply { +impl serde::Serialize for LinkedBlob { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8814,45 +9003,37 @@ impl serde::Serialize for PullImageReply { { use serde::ser::SerializeStruct; let mut len = 0; - if self.progress.is_some() { + if !self.store.is_empty() { len += 1; } - if self.spec.is_some() { - len += 1; - } - if self.metadata.is_some() { + if !self.digest.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.PullImageReply", len)?; - if let Some(v) = self.progress.as_ref() { - struct_ser.serialize_field("progress", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.LinkedBlob", len)?; + if !self.store.is_empty() { + struct_ser.serialize_field("store", &self.store)?; } - if let Some(v) = self.spec.as_ref() { - struct_ser.serialize_field("spec", v)?; - } - if let Some(v) = self.metadata.as_ref() { - struct_ser.serialize_field("metadata", v)?; + if !self.digest.is_empty() { + struct_ser.serialize_field("digest", &self.digest)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for PullImageReply { +impl<'de> serde::Deserialize<'de> for LinkedBlob { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "progress", - "spec", - "metadata", + "store", + "digest", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Progress, - Spec, - Metadata, + Store, + Digest, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8874,9 +9055,8 @@ impl<'de> serde::Deserialize<'de> for PullImageReply { E: serde::de::Error, { match value { - "progress" => Ok(GeneratedField::Progress), - "spec" => Ok(GeneratedField::Spec), - "metadata" => Ok(GeneratedField::Metadata), + "store" => Ok(GeneratedField::Store), + "digest" => Ok(GeneratedField::Digest), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8886,52 +9066,44 @@ impl<'de> serde::Deserialize<'de> for PullImageReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PullImageReply; + type Value = LinkedBlob; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.PullImageReply") + formatter.write_str("struct protect.control.v1.LinkedBlob") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut progress__ = None; - let mut spec__ = None; - let mut metadata__ = None; + let mut store__ = None; + let mut digest__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Progress => { - if progress__.is_some() { - return Err(serde::de::Error::duplicate_field("progress")); - } - progress__ = map_.next_value()?; - } - GeneratedField::Spec => { - if spec__.is_some() { - return Err(serde::de::Error::duplicate_field("spec")); + GeneratedField::Store => { + if store__.is_some() { + return Err(serde::de::Error::duplicate_field("store")); } - spec__ = map_.next_value()?; + store__ = Some(map_.next_value()?); } - GeneratedField::Metadata => { - if metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("metadata")); + GeneratedField::Digest => { + if digest__.is_some() { + return Err(serde::de::Error::duplicate_field("digest")); } - metadata__ = map_.next_value()?; + digest__ = Some(map_.next_value()?); } } } - Ok(PullImageReply { - progress: progress__, - spec: spec__, - metadata: metadata__, + Ok(LinkedBlob { + store: store__.unwrap_or_default(), + digest: digest__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.PullImageReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.LinkedBlob", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for PullImageRequest { +impl serde::Serialize for ListDevicesReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8939,73 +9111,29 @@ impl serde::Serialize for PullImageRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.image.is_empty() { - len += 1; - } - if self.format != 0 { - len += 1; - } - if self.overwrite_cache { - len += 1; - } - if self.update { - len += 1; - } - if self.want_metadata { - len += 1; - } - if self.auth.is_some() { + if !self.devices.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.PullImageRequest", len)?; - if !self.image.is_empty() { - struct_ser.serialize_field("image", &self.image)?; - } - if self.format != 0 { - let v = OciImageFormat::try_from(self.format) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; - struct_ser.serialize_field("format", &v)?; - } - if self.overwrite_cache { - struct_ser.serialize_field("overwriteCache", &self.overwrite_cache)?; - } - if self.update { - struct_ser.serialize_field("update", &self.update)?; - } - if self.want_metadata { - struct_ser.serialize_field("wantMetadata", &self.want_metadata)?; - } - if let Some(v) = self.auth.as_ref() { - struct_ser.serialize_field("auth", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListDevicesReply", len)?; + if !self.devices.is_empty() { + struct_ser.serialize_field("devices", &self.devices)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for PullImageRequest { +impl<'de> serde::Deserialize<'de> for ListDevicesReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "image", - "format", - "overwrite_cache", - "overwriteCache", - "update", - "want_metadata", - "wantMetadata", - "auth", + "devices", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Image, - Format, - OverwriteCache, - Update, - WantMetadata, - Auth, + Devices, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9027,12 +9155,7 @@ impl<'de> serde::Deserialize<'de> for PullImageRequest { E: serde::de::Error, { match value { - "image" => Ok(GeneratedField::Image), - "format" => Ok(GeneratedField::Format), - "overwriteCache" | "overwrite_cache" => Ok(GeneratedField::OverwriteCache), - "update" => Ok(GeneratedField::Update), - "wantMetadata" | "want_metadata" => Ok(GeneratedField::WantMetadata), - "auth" => Ok(GeneratedField::Auth), + "devices" => Ok(GeneratedField::Devices), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -9042,106 +9165,58 @@ impl<'de> serde::Deserialize<'de> for PullImageRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PullImageRequest; + type Value = ListDevicesReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.PullImageRequest") + formatter.write_str("struct protect.control.v1.ListDevicesReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut image__ = None; - let mut format__ = None; - let mut overwrite_cache__ = None; - let mut update__ = None; - let mut want_metadata__ = None; - let mut auth__ = None; + let mut devices__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Image => { - if image__.is_some() { - return Err(serde::de::Error::duplicate_field("image")); - } - image__ = Some(map_.next_value()?); - } - GeneratedField::Format => { - if format__.is_some() { - return Err(serde::de::Error::duplicate_field("format")); - } - format__ = Some(map_.next_value::()? as i32); - } - GeneratedField::OverwriteCache => { - if overwrite_cache__.is_some() { - return Err(serde::de::Error::duplicate_field("overwriteCache")); - } - overwrite_cache__ = Some(map_.next_value()?); - } - GeneratedField::Update => { - if update__.is_some() { - return Err(serde::de::Error::duplicate_field("update")); - } - update__ = Some(map_.next_value()?); - } - GeneratedField::WantMetadata => { - if want_metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("wantMetadata")); - } - want_metadata__ = Some(map_.next_value()?); - } - GeneratedField::Auth => { - if auth__.is_some() { - return Err(serde::de::Error::duplicate_field("auth")); + GeneratedField::Devices => { + if devices__.is_some() { + return Err(serde::de::Error::duplicate_field("devices")); } - auth__ = map_.next_value()?; + devices__ = Some(map_.next_value()?); } } } - Ok(PullImageRequest { - image: image__.unwrap_or_default(), - format: format__.unwrap_or_default(), - overwrite_cache: overwrite_cache__.unwrap_or_default(), - update: update__.unwrap_or_default(), - want_metadata: want_metadata__.unwrap_or_default(), - auth: auth__, + Ok(ListDevicesReply { + devices: devices__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.PullImageRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListDevicesReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ReadHypervisorConsoleReply { +impl serde::Serialize for ListDevicesRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.data.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ReadHypervisorConsoleReply", len)?; - if !self.data.is_empty() { - struct_ser.serialize_field("data", &self.data)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ListDevicesRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ReadHypervisorConsoleReply { +impl<'de> serde::Deserialize<'de> for ListDevicesRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "data", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Data, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9162,10 +9237,7 @@ impl<'de> serde::Deserialize<'de> for ReadHypervisorConsoleReply { where E: serde::de::Error, { - match value { - "data" => Ok(GeneratedField::Data), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -9173,58 +9245,57 @@ impl<'de> serde::Deserialize<'de> for ReadHypervisorConsoleReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ReadHypervisorConsoleReply; + type Value = ListDevicesRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ReadHypervisorConsoleReply") + formatter.write_str("struct protect.control.v1.ListDevicesRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut data__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Data => { - if data__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); - } - data__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(ReadHypervisorConsoleReply { - data: data__.unwrap_or_default(), + Ok(ListDevicesRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.ReadHypervisorConsoleReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListDevicesRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ReadHypervisorConsoleRequest { +impl serde::Serialize for ListImagesReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.ReadHypervisorConsoleRequest", len)?; + let mut len = 0; + if !self.images.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListImagesReply", len)?; + if !self.images.is_empty() { + struct_ser.serialize_field("images", &self.images)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ReadHypervisorConsoleRequest { +impl<'de> serde::Deserialize<'de> for ListImagesReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "images", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Images, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9245,7 +9316,10 @@ impl<'de> serde::Deserialize<'de> for ReadHypervisorConsoleRequest { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "images" => Ok(GeneratedField::Images), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -9253,57 +9327,58 @@ impl<'de> serde::Deserialize<'de> for ReadHypervisorConsoleRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ReadHypervisorConsoleRequest; + type Value = ListImagesReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ReadHypervisorConsoleRequest") + formatter.write_str("struct protect.control.v1.ListImagesReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; - } - Ok(ReadHypervisorConsoleRequest { - }) + let mut images__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Images => { + if images__.is_some() { + return Err(serde::de::Error::duplicate_field("images")); + } + images__ = Some(map_.next_value()?); + } + } + } + Ok(ListImagesReply { + images: images__.unwrap_or_default(), + }) } } - deserializer.deserialize_struct("protect.control.v1.ReadHypervisorConsoleRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListImagesReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ReadZoneMetricsReply { +impl serde::Serialize for ListImagesRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if self.root.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ReadZoneMetricsReply", len)?; - if let Some(v) = self.root.as_ref() { - struct_ser.serialize_field("root", v)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ListImagesRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ReadZoneMetricsReply { +impl<'de> serde::Deserialize<'de> for ListImagesRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "root", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Root, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9324,10 +9399,7 @@ impl<'de> serde::Deserialize<'de> for ReadZoneMetricsReply { where E: serde::de::Error, { - match value { - "root" => Ok(GeneratedField::Root), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -9335,36 +9407,27 @@ impl<'de> serde::Deserialize<'de> for ReadZoneMetricsReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ReadZoneMetricsReply; + type Value = ListImagesRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ReadZoneMetricsReply") + formatter.write_str("struct protect.control.v1.ListImagesRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut root__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Root => { - if root__.is_some() { - return Err(serde::de::Error::duplicate_field("root")); - } - root__ = map_.next_value()?; - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(ReadZoneMetricsReply { - root: root__, + Ok(ListImagesRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.ReadZoneMetricsReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListImagesRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ReadZoneMetricsRequest { +impl serde::Serialize for ListKernelVariantsReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9372,30 +9435,29 @@ impl serde::Serialize for ReadZoneMetricsRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { + if !self.variants.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ReadZoneMetricsRequest", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListKernelVariantsReply", len)?; + if !self.variants.is_empty() { + struct_ser.serialize_field("variants", &self.variants)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ReadZoneMetricsRequest { +impl<'de> serde::Deserialize<'de> for ListKernelVariantsReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", + "variants", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, + Variants, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9417,7 +9479,7 @@ impl<'de> serde::Deserialize<'de> for ReadZoneMetricsRequest { E: serde::de::Error, { match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "variants" => Ok(GeneratedField::Variants), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -9427,66 +9489,58 @@ impl<'de> serde::Deserialize<'de> for ReadZoneMetricsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ReadZoneMetricsRequest; + type Value = ListKernelVariantsReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ReadZoneMetricsRequest") + formatter.write_str("struct protect.control.v1.ListKernelVariantsReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; + let mut variants__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); + GeneratedField::Variants => { + if variants__.is_some() { + return Err(serde::de::Error::duplicate_field("variants")); } - zone_id__ = Some(map_.next_value()?); + variants__ = Some(map_.next_value()?); } } } - Ok(ReadZoneMetricsRequest { - zone_id: zone_id__.unwrap_or_default(), + Ok(ListKernelVariantsReply { + variants: variants__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ReadZoneMetricsRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListKernelVariantsReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for RemoveImageReply { +impl serde::Serialize for ListKernelVariantsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if self.removed { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.RemoveImageReply", len)?; - if self.removed { - struct_ser.serialize_field("removed", &self.removed)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ListKernelVariantsRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for RemoveImageReply { +impl<'de> serde::Deserialize<'de> for ListKernelVariantsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "removed", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Removed, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9507,10 +9561,7 @@ impl<'de> serde::Deserialize<'de> for RemoveImageReply { where E: serde::de::Error, { - match value { - "removed" => Ok(GeneratedField::Removed), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -9518,36 +9569,27 @@ impl<'de> serde::Deserialize<'de> for RemoveImageReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = RemoveImageReply; + type Value = ListKernelVariantsRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.RemoveImageReply") + formatter.write_str("struct protect.control.v1.ListKernelVariantsRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut removed__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Removed => { - if removed__.is_some() { - return Err(serde::de::Error::duplicate_field("removed")); - } - removed__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(RemoveImageReply { - removed: removed__.unwrap_or_default(), + Ok(ListKernelVariantsRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.RemoveImageReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListKernelVariantsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for RemoveImageRequest { +impl serde::Serialize for ListNetworkReservationsReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9555,39 +9597,29 @@ impl serde::Serialize for RemoveImageRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.digest.is_empty() { - len += 1; - } - if self.format != 0 { + if !self.reservations.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.RemoveImageRequest", len)?; - if !self.digest.is_empty() { - struct_ser.serialize_field("digest", &self.digest)?; - } - if self.format != 0 { - let v = OciImageFormat::try_from(self.format) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; - struct_ser.serialize_field("format", &v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListNetworkReservationsReply", len)?; + if !self.reservations.is_empty() { + struct_ser.serialize_field("reservations", &self.reservations)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for RemoveImageRequest { +impl<'de> serde::Deserialize<'de> for ListNetworkReservationsReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "digest", - "format", + "reservations", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Digest, - Format, + Reservations, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9609,8 +9641,7 @@ impl<'de> serde::Deserialize<'de> for RemoveImageRequest { E: serde::de::Error, { match value { - "digest" => Ok(GeneratedField::Digest), - "format" => Ok(GeneratedField::Format), + "reservations" => Ok(GeneratedField::Reservations), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -9620,75 +9651,58 @@ impl<'de> serde::Deserialize<'de> for RemoveImageRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = RemoveImageRequest; + type Value = ListNetworkReservationsReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.RemoveImageRequest") + formatter.write_str("struct protect.control.v1.ListNetworkReservationsReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut digest__ = None; - let mut format__ = None; + let mut reservations__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Digest => { - if digest__.is_some() { - return Err(serde::de::Error::duplicate_field("digest")); - } - digest__ = Some(map_.next_value()?); - } - GeneratedField::Format => { - if format__.is_some() { - return Err(serde::de::Error::duplicate_field("format")); + GeneratedField::Reservations => { + if reservations__.is_some() { + return Err(serde::de::Error::duplicate_field("reservations")); } - format__ = Some(map_.next_value::()? as i32); + reservations__ = Some(map_.next_value()?); } } } - Ok(RemoveImageRequest { - digest: digest__.unwrap_or_default(), - format: format__.unwrap_or_default(), + Ok(ListNetworkReservationsReply { + reservations: reservations__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.RemoveImageRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListNetworkReservationsReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ResolveWorkloadIdReply { +impl serde::Serialize for ListNetworkReservationsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.workload_id.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveWorkloadIdReply", len)?; - if !self.workload_id.is_empty() { - struct_ser.serialize_field("workloadId", &self.workload_id)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ListNetworkReservationsRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdReply { +impl<'de> serde::Deserialize<'de> for ListNetworkReservationsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload_id", - "workloadId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WorkloadId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9709,10 +9723,7 @@ impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdReply { where E: serde::de::Error, { - match value { - "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -9720,36 +9731,27 @@ impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ResolveWorkloadIdReply; + type Value = ListNetworkReservationsRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ResolveWorkloadIdReply") + formatter.write_str("struct protect.control.v1.ListNetworkReservationsRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload_id__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::WorkloadId => { - if workload_id__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadId")); - } - workload_id__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(ResolveWorkloadIdReply { - workload_id: workload_id__.unwrap_or_default(), + Ok(ListNetworkReservationsRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.ResolveWorkloadIdReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListNetworkReservationsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ResolveWorkloadIdRequest { +impl serde::Serialize for ListObjectCapabilitiesReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9757,29 +9759,30 @@ impl serde::Serialize for ResolveWorkloadIdRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { + if !self.object_capabilities.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveWorkloadIdRequest", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListObjectCapabilitiesReply", len)?; + if !self.object_capabilities.is_empty() { + struct_ser.serialize_field("objectCapabilities", &self.object_capabilities)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdRequest { +impl<'de> serde::Deserialize<'de> for ListObjectCapabilitiesReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", + "object_capabilities", + "objectCapabilities", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, + ObjectCapabilities, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9801,7 +9804,7 @@ impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdRequest { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), + "objectCapabilities" | "object_capabilities" => Ok(GeneratedField::ObjectCapabilities), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -9811,67 +9814,58 @@ impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ResolveWorkloadIdRequest; + type Value = ListObjectCapabilitiesReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ResolveWorkloadIdRequest") + formatter.write_str("struct protect.control.v1.ListObjectCapabilitiesReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; + let mut object_capabilities__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); + GeneratedField::ObjectCapabilities => { + if object_capabilities__.is_some() { + return Err(serde::de::Error::duplicate_field("objectCapabilities")); } - name__ = Some(map_.next_value()?); + object_capabilities__ = Some(map_.next_value()?); } } } - Ok(ResolveWorkloadIdRequest { - name: name__.unwrap_or_default(), + Ok(ListObjectCapabilitiesReply { + object_capabilities: object_capabilities__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ResolveWorkloadIdRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListObjectCapabilitiesReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ResolveWorkloadIdsReply { +impl serde::Serialize for ListObjectCapabilitiesRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.workload_ids.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveWorkloadIdsReply", len)?; - if !self.workload_ids.is_empty() { - struct_ser.serialize_field("workloadIds", &self.workload_ids)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ListObjectCapabilitiesRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdsReply { +impl<'de> serde::Deserialize<'de> for ListObjectCapabilitiesRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload_ids", - "workloadIds", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WorkloadIds, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9892,10 +9886,7 @@ impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdsReply { where E: serde::de::Error, { - match value { - "workloadIds" | "workload_ids" => Ok(GeneratedField::WorkloadIds), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -9903,36 +9894,27 @@ impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdsReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ResolveWorkloadIdsReply; + type Value = ListObjectCapabilitiesRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ResolveWorkloadIdsReply") + formatter.write_str("struct protect.control.v1.ListObjectCapabilitiesRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload_ids__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::WorkloadIds => { - if workload_ids__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadIds")); - } - workload_ids__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(ResolveWorkloadIdsReply { - workload_ids: workload_ids__.unwrap_or_default(), + Ok(ListObjectCapabilitiesRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.ResolveWorkloadIdsReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListObjectCapabilitiesRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ResolveWorkloadIdsRequest { +impl serde::Serialize for ListWorkloadsReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9940,29 +9922,29 @@ impl serde::Serialize for ResolveWorkloadIdsRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { + if !self.workloads.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveWorkloadIdsRequest", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListWorkloadsReply", len)?; + if !self.workloads.is_empty() { + struct_ser.serialize_field("workloads", &self.workloads)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdsRequest { +impl<'de> serde::Deserialize<'de> for ListWorkloadsReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", + "workloads", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, + Workloads, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9984,7 +9966,7 @@ impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdsRequest { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), + "workloads" => Ok(GeneratedField::Workloads), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -9994,67 +9976,58 @@ impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ResolveWorkloadIdsRequest; + type Value = ListWorkloadsReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ResolveWorkloadIdsRequest") + formatter.write_str("struct protect.control.v1.ListWorkloadsReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; + let mut workloads__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); + GeneratedField::Workloads => { + if workloads__.is_some() { + return Err(serde::de::Error::duplicate_field("workloads")); } - name__ = Some(map_.next_value()?); + workloads__ = Some(map_.next_value()?); } } } - Ok(ResolveWorkloadIdsRequest { - name: name__.unwrap_or_default(), + Ok(ListWorkloadsReply { + workloads: workloads__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ResolveWorkloadIdsRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListWorkloadsReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ResolveZoneIdReply { +impl serde::Serialize for ListWorkloadsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.zone_id.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveZoneIdReply", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ListWorkloadsRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ResolveZoneIdReply { +impl<'de> serde::Deserialize<'de> for ListWorkloadsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10075,10 +10048,7 @@ impl<'de> serde::Deserialize<'de> for ResolveZoneIdReply { where E: serde::de::Error, { - match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -10086,36 +10056,27 @@ impl<'de> serde::Deserialize<'de> for ResolveZoneIdReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ResolveZoneIdReply; + type Value = ListWorkloadsRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ResolveZoneIdReply") + formatter.write_str("struct protect.control.v1.ListWorkloadsRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); - } - zone_id__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(ResolveZoneIdReply { - zone_id: zone_id__.unwrap_or_default(), + Ok(ListWorkloadsRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.ResolveZoneIdReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListWorkloadsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ResolveZoneIdRequest { +impl serde::Serialize for ListZonesReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -10123,29 +10084,29 @@ impl serde::Serialize for ResolveZoneIdRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { + if !self.zones.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveZoneIdRequest", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ListZonesReply", len)?; + if !self.zones.is_empty() { + struct_ser.serialize_field("zones", &self.zones)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ResolveZoneIdRequest { +impl<'de> serde::Deserialize<'de> for ListZonesReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", + "zones", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, + Zones, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10167,7 +10128,7 @@ impl<'de> serde::Deserialize<'de> for ResolveZoneIdRequest { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), + "zones" => Ok(GeneratedField::Zones), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10177,67 +10138,58 @@ impl<'de> serde::Deserialize<'de> for ResolveZoneIdRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ResolveZoneIdRequest; + type Value = ListZonesReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ResolveZoneIdRequest") + formatter.write_str("struct protect.control.v1.ListZonesReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; + let mut zones__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); + GeneratedField::Zones => { + if zones__.is_some() { + return Err(serde::de::Error::duplicate_field("zones")); } - name__ = Some(map_.next_value()?); + zones__ = Some(map_.next_value()?); } } } - Ok(ResolveZoneIdRequest { - name: name__.unwrap_or_default(), + Ok(ListZonesReply { + zones: zones__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ResolveZoneIdRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListZonesReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ResolveZoneIdsReply { +impl serde::Serialize for ListZonesRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.zone_ids.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveZoneIdsReply", len)?; - if !self.zone_ids.is_empty() { - struct_ser.serialize_field("zoneIds", &self.zone_ids)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ListZonesRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ResolveZoneIdsReply { +impl<'de> serde::Deserialize<'de> for ListZonesRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_ids", - "zoneIds", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneIds, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10258,10 +10210,7 @@ impl<'de> serde::Deserialize<'de> for ResolveZoneIdsReply { where E: serde::de::Error, { - match value { - "zoneIds" | "zone_ids" => Ok(GeneratedField::ZoneIds), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -10269,149 +10218,163 @@ impl<'de> serde::Deserialize<'de> for ResolveZoneIdsReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ResolveZoneIdsReply; + type Value = ListZonesRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ResolveZoneIdsReply") + formatter.write_str("struct protect.control.v1.ListZonesRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_ids__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::ZoneIds => { - if zone_ids__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneIds")); - } - zone_ids__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(ResolveZoneIdsReply { - zone_ids: zone_ids__.unwrap_or_default(), + Ok(ListZonesRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.ResolveZoneIdsReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ListZonesRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ResolveZoneIdsRequest { +impl serde::Serialize for MetricFormat { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveZoneIdsRequest", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - struct_ser.end() + let variant = match self { + Self::Unknown => "METRIC_FORMAT_UNKNOWN", + Self::Bytes => "METRIC_FORMAT_BYTES", + Self::Integer => "METRIC_FORMAT_INTEGER", + Self::DurationSeconds => "METRIC_FORMAT_DURATION_SECONDS", + Self::Percent => "METRIC_FORMAT_PERCENT", + }; + serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for ResolveZoneIdsRequest { +impl<'de> serde::Deserialize<'de> for MetricFormat { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", + "METRIC_FORMAT_UNKNOWN", + "METRIC_FORMAT_BYTES", + "METRIC_FORMAT_INTEGER", + "METRIC_FORMAT_DURATION_SECONDS", + "METRIC_FORMAT_PERCENT", ]; - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - } - 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 { - "name" => Ok(GeneratedField::Name), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ResolveZoneIdsRequest; + type Value = MetricFormat; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ResolveZoneIdsRequest") + write!(formatter, "expected one of: {:?}", &FIELDS) } - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, { - let mut name__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map_.next_value()?); - } - } + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "METRIC_FORMAT_UNKNOWN" => Ok(MetricFormat::Unknown), + "METRIC_FORMAT_BYTES" => Ok(MetricFormat::Bytes), + "METRIC_FORMAT_INTEGER" => Ok(MetricFormat::Integer), + "METRIC_FORMAT_DURATION_SECONDS" => Ok(MetricFormat::DurationSeconds), + "METRIC_FORMAT_PERCENT" => Ok(MetricFormat::Percent), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } - Ok(ResolveZoneIdsRequest { - name: name__.unwrap_or_default(), - }) } } - deserializer.deserialize_struct("protect.control.v1.ResolveZoneIdsRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for SetHostPowerManagementPolicyReply { +impl serde::Serialize for MetricNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.SetHostPowerManagementPolicyReply", len)?; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if self.value.is_some() { + len += 1; + } + if self.format != 0 { + len += 1; + } + if !self.children.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.MetricNode", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if let Some(v) = self.value.as_ref() { + struct_ser.serialize_field("value", v)?; + } + if self.format != 0 { + let v = MetricFormat::try_from(self.format) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; + struct_ser.serialize_field("format", &v)?; + } + if !self.children.is_empty() { + struct_ser.serialize_field("children", &self.children)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for SetHostPowerManagementPolicyReply { +impl<'de> serde::Deserialize<'de> for MetricNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "name", + "value", + "format", + "children", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Name, + Value, + Format, + Children, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10432,7 +10395,13 @@ impl<'de> serde::Deserialize<'de> for SetHostPowerManagementPolicyReply { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "name" => Ok(GeneratedField::Name), + "value" => Ok(GeneratedField::Value), + "format" => Ok(GeneratedField::Format), + "children" => Ok(GeneratedField::Children), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -10440,27 +10409,60 @@ impl<'de> serde::Deserialize<'de> for SetHostPowerManagementPolicyReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SetHostPowerManagementPolicyReply; + type Value = MetricNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.SetHostPowerManagementPolicyReply") + formatter.write_str("struct protect.control.v1.MetricNode") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut name__ = None; + let mut value__ = None; + let mut format__ = None; + let mut children__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = map_.next_value()?; + } + GeneratedField::Format => { + if format__.is_some() { + return Err(serde::de::Error::duplicate_field("format")); + } + format__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Children => { + if children__.is_some() { + return Err(serde::de::Error::duplicate_field("children")); + } + children__ = Some(map_.next_value()?); + } + } } - Ok(SetHostPowerManagementPolicyReply { + Ok(MetricNode { + name: name__.unwrap_or_default(), + value: value__, + format: format__.unwrap_or_default(), + children: children__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.SetHostPowerManagementPolicyReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.MetricNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for SetHostPowerManagementPolicyRequest { +impl serde::Serialize for MonitorZoneKernelEventReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -10468,38 +10470,49 @@ impl serde::Serialize for SetHostPowerManagementPolicyRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.scheduler.is_empty() { - len += 1; - } - if self.smt_awareness { + if self.reply.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.SetHostPowerManagementPolicyRequest", len)?; - if !self.scheduler.is_empty() { - struct_ser.serialize_field("scheduler", &self.scheduler)?; - } - if self.smt_awareness { - struct_ser.serialize_field("smtAwareness", &self.smt_awareness)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.MonitorZoneKernelEventReply", len)?; + if let Some(v) = self.reply.as_ref() { + match v { + monitor_zone_kernel_event_reply::Reply::Syscall(v) => { + struct_ser.serialize_field("syscall", v)?; + } + monitor_zone_kernel_event_reply::Reply::Threadsnap(v) => { + struct_ser.serialize_field("threadsnap", v)?; + } + monitor_zone_kernel_event_reply::Reply::Started(v) => { + struct_ser.serialize_field("started", v)?; + } + monitor_zone_kernel_event_reply::Reply::NetworkEvents(v) => { + struct_ser.serialize_field("networkEvents", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for SetHostPowerManagementPolicyRequest { +impl<'de> serde::Deserialize<'de> for MonitorZoneKernelEventReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "scheduler", - "smt_awareness", - "smtAwareness", + "syscall", + "threadsnap", + "started", + "network_events", + "networkEvents", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Scheduler, - SmtAwareness, + Syscall, + Threadsnap, + Started, + NetworkEvents, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10521,8 +10534,10 @@ impl<'de> serde::Deserialize<'de> for SetHostPowerManagementPolicyRequest { E: serde::de::Error, { match value { - "scheduler" => Ok(GeneratedField::Scheduler), - "smtAwareness" | "smt_awareness" => Ok(GeneratedField::SmtAwareness), + "syscall" => Ok(GeneratedField::Syscall), + "threadsnap" => Ok(GeneratedField::Threadsnap), + "started" => Ok(GeneratedField::Started), + "networkEvents" | "network_events" => Ok(GeneratedField::NetworkEvents), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10532,44 +10547,58 @@ impl<'de> serde::Deserialize<'de> for SetHostPowerManagementPolicyRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SetHostPowerManagementPolicyRequest; + type Value = MonitorZoneKernelEventReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.SetHostPowerManagementPolicyRequest") + formatter.write_str("struct protect.control.v1.MonitorZoneKernelEventReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut scheduler__ = None; - let mut smt_awareness__ = None; + let mut reply__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Scheduler => { - if scheduler__.is_some() { - return Err(serde::de::Error::duplicate_field("scheduler")); + GeneratedField::Syscall => { + if reply__.is_some() { + return Err(serde::de::Error::duplicate_field("syscall")); } - scheduler__ = Some(map_.next_value()?); + reply__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_reply::Reply::Syscall) +; } - GeneratedField::SmtAwareness => { - if smt_awareness__.is_some() { - return Err(serde::de::Error::duplicate_field("smtAwareness")); + GeneratedField::Threadsnap => { + if reply__.is_some() { + return Err(serde::de::Error::duplicate_field("threadsnap")); } - smt_awareness__ = Some(map_.next_value()?); + reply__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_reply::Reply::Threadsnap) +; + } + GeneratedField::Started => { + if reply__.is_some() { + return Err(serde::de::Error::duplicate_field("started")); + } + reply__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_reply::Reply::Started) +; + } + GeneratedField::NetworkEvents => { + if reply__.is_some() { + return Err(serde::de::Error::duplicate_field("networkEvents")); + } + reply__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_reply::Reply::NetworkEvents) +; } } } - Ok(SetHostPowerManagementPolicyRequest { - scheduler: scheduler__.unwrap_or_default(), - smt_awareness: smt_awareness__.unwrap_or_default(), + Ok(MonitorZoneKernelEventReply { + reply: reply__, }) } } - deserializer.deserialize_struct("protect.control.v1.SetHostPowerManagementPolicyRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.MonitorZoneKernelEventReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for SnoopIdmPacket { +impl serde::Serialize for MonitorZoneKernelEventRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -10577,47 +10606,47 @@ impl serde::Serialize for SnoopIdmPacket { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.from.is_empty() { + if !self.zone_id.is_empty() { len += 1; } - if !self.to.is_empty() { + if self.request.is_some() { len += 1; } - if !self.packet.is_empty() { - len += 1; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.MonitorZoneKernelEventRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.SnoopIdmPacket", len)?; - if !self.from.is_empty() { - struct_ser.serialize_field("from", &self.from)?; - } - if !self.to.is_empty() { - struct_ser.serialize_field("to", &self.to)?; - } - if !self.packet.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("packet", pbjson::private::base64::encode(&self.packet).as_str())?; + if let Some(v) = self.request.as_ref() { + match v { + monitor_zone_kernel_event_request::Request::Update(v) => { + struct_ser.serialize_field("update", v)?; + } + monitor_zone_kernel_event_request::Request::Stop(v) => { + struct_ser.serialize_field("stop", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for SnoopIdmPacket { +impl<'de> serde::Deserialize<'de> for MonitorZoneKernelEventRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "from", - "to", - "packet", + "zone_id", + "zoneId", + "update", + "stop", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - From, - To, - Packet, + ZoneId, + Update, + Stop, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10639,9 +10668,9 @@ impl<'de> serde::Deserialize<'de> for SnoopIdmPacket { E: serde::de::Error, { match value { - "from" => Ok(GeneratedField::From), - "to" => Ok(GeneratedField::To), - "packet" => Ok(GeneratedField::Packet), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "update" => Ok(GeneratedField::Update), + "stop" => Ok(GeneratedField::Stop), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10651,54 +10680,126 @@ impl<'de> serde::Deserialize<'de> for SnoopIdmPacket { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SnoopIdmPacket; + type Value = MonitorZoneKernelEventRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.SnoopIdmPacket") + formatter.write_str("struct protect.control.v1.MonitorZoneKernelEventRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut from__ = None; - let mut to__ = None; - let mut packet__ = None; + let mut zone_id__ = None; + let mut request__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::From => { - if from__.is_some() { - return Err(serde::de::Error::duplicate_field("from")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - from__ = Some(map_.next_value()?); + zone_id__ = Some(map_.next_value()?); } - GeneratedField::To => { - if to__.is_some() { - return Err(serde::de::Error::duplicate_field("to")); + GeneratedField::Update => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("update")); } - to__ = Some(map_.next_value()?); + request__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_request::Request::Update) +; } - GeneratedField::Packet => { - if packet__.is_some() { - return Err(serde::de::Error::duplicate_field("packet")); + GeneratedField::Stop => { + if request__.is_some() { + return Err(serde::de::Error::duplicate_field("stop")); } - packet__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + request__ = map_.next_value::<::std::option::Option<_>>()?.map(monitor_zone_kernel_event_request::Request::Stop) +; } } } - Ok(SnoopIdmPacket { - from: from__.unwrap_or_default(), - to: to__.unwrap_or_default(), - packet: packet__.unwrap_or_default(), + Ok(MonitorZoneKernelEventRequest { + zone_id: zone_id__.unwrap_or_default(), + request: request__, }) } } - deserializer.deserialize_struct("protect.control.v1.SnoopIdmPacket", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.MonitorZoneKernelEventRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for SnoopIdmReply { +impl serde::Serialize for MountCacheMode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "MOUNT_CACHE_MODE_UNKNOWN", + Self::Cached => "MOUNT_CACHE_MODE_CACHED", + Self::None => "MOUNT_CACHE_MODE_NONE", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for MountCacheMode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "MOUNT_CACHE_MODE_UNKNOWN", + "MOUNT_CACHE_MODE_CACHED", + "MOUNT_CACHE_MODE_NONE", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MountCacheMode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "MOUNT_CACHE_MODE_UNKNOWN" => Ok(MountCacheMode::Unknown), + "MOUNT_CACHE_MODE_CACHED" => Ok(MountCacheMode::Cached), + "MOUNT_CACHE_MODE_NONE" => Ok(MountCacheMode::None), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for MountSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -10706,39 +10807,67 @@ impl serde::Serialize for SnoopIdmReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.packets.is_empty() { + if !self.host_path.is_empty() { len += 1; } - if self.skipped != 0 { + if !self.target_path.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.SnoopIdmReply", len)?; - if !self.packets.is_empty() { - struct_ser.serialize_field("packets", &self.packets)?; + if self.read_only { + len += 1; } - if self.skipped != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("skipped", ToString::to_string(&self.skipped).as_str())?; + if self.cache != 0 { + len += 1; + } + if !self.spec_host_path.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.MountSpec", len)?; + if !self.host_path.is_empty() { + struct_ser.serialize_field("hostPath", &self.host_path)?; + } + if !self.target_path.is_empty() { + struct_ser.serialize_field("targetPath", &self.target_path)?; + } + if self.read_only { + struct_ser.serialize_field("readOnly", &self.read_only)?; + } + if self.cache != 0 { + let v = MountCacheMode::try_from(self.cache) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache)))?; + struct_ser.serialize_field("cache", &v)?; + } + if !self.spec_host_path.is_empty() { + struct_ser.serialize_field("specHostPath", &self.spec_host_path)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for SnoopIdmReply { +impl<'de> serde::Deserialize<'de> for MountSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "packets", - "skipped", + "host_path", + "hostPath", + "target_path", + "targetPath", + "read_only", + "readOnly", + "cache", + "spec_host_path", + "specHostPath", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Packets, - Skipped, + HostPath, + TargetPath, + ReadOnly, + Cache, + SpecHostPath, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10760,8 +10889,11 @@ impl<'de> serde::Deserialize<'de> for SnoopIdmReply { E: serde::de::Error, { match value { - "packets" => Ok(GeneratedField::Packets), - "skipped" => Ok(GeneratedField::Skipped), + "hostPath" | "host_path" => Ok(GeneratedField::HostPath), + "targetPath" | "target_path" => Ok(GeneratedField::TargetPath), + "readOnly" | "read_only" => Ok(GeneratedField::ReadOnly), + "cache" => Ok(GeneratedField::Cache), + "specHostPath" | "spec_host_path" => Ok(GeneratedField::SpecHostPath), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10771,219 +10903,149 @@ impl<'de> serde::Deserialize<'de> for SnoopIdmReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SnoopIdmReply; + type Value = MountSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.SnoopIdmReply") + formatter.write_str("struct protect.control.v1.MountSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut packets__ = None; - let mut skipped__ = None; + let mut host_path__ = None; + let mut target_path__ = None; + let mut read_only__ = None; + let mut cache__ = None; + let mut spec_host_path__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Packets => { - if packets__.is_some() { - return Err(serde::de::Error::duplicate_field("packets")); + GeneratedField::HostPath => { + if host_path__.is_some() { + return Err(serde::de::Error::duplicate_field("hostPath")); } - packets__ = Some(map_.next_value()?); + host_path__ = Some(map_.next_value()?); } - GeneratedField::Skipped => { - if skipped__.is_some() { - return Err(serde::de::Error::duplicate_field("skipped")); + GeneratedField::TargetPath => { + if target_path__.is_some() { + return Err(serde::de::Error::duplicate_field("targetPath")); } - skipped__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + target_path__ = Some(map_.next_value()?); + } + GeneratedField::ReadOnly => { + if read_only__.is_some() { + return Err(serde::de::Error::duplicate_field("readOnly")); + } + read_only__ = Some(map_.next_value()?); + } + GeneratedField::Cache => { + if cache__.is_some() { + return Err(serde::de::Error::duplicate_field("cache")); + } + cache__ = Some(map_.next_value::()? as i32); + } + GeneratedField::SpecHostPath => { + if spec_host_path__.is_some() { + return Err(serde::de::Error::duplicate_field("specHostPath")); + } + spec_host_path__ = Some(map_.next_value()?); } } } - Ok(SnoopIdmReply { - packets: packets__.unwrap_or_default(), - skipped: skipped__.unwrap_or_default(), + Ok(MountSpec { + host_path: host_path__.unwrap_or_default(), + target_path: target_path__.unwrap_or_default(), + read_only: read_only__.unwrap_or_default(), + cache: cache__.unwrap_or_default(), + spec_host_path: spec_host_path__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.SnoopIdmReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.MountSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for SnoopIdmRequest { +impl serde::Serialize for NetworkReservation { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.SnoopIdmRequest", len)?; - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for SnoopIdmRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { + let mut len = 0; + if !self.uuid.is_empty() { + len += 1; } - 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, - { - Err(serde::de::Error::unknown_field(value, FIELDS)) - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } + if !self.ipv4.is_empty() { + len += 1; } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SnoopIdmRequest; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.SnoopIdmRequest") - } - - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; - } - Ok(SnoopIdmRequest { - }) - } + if !self.ipv6.is_empty() { + len += 1; } - deserializer.deserialize_struct("protect.control.v1.SnoopIdmRequest", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for StartWorkloadReply { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.StartWorkloadReply", len)?; - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for StartWorkloadReply { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { + if !self.mac.is_empty() { + len += 1; } - 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, - { - Err(serde::de::Error::unknown_field(value, FIELDS)) - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } + if !self.gateway_ipv4.is_empty() { + len += 1; } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = StartWorkloadReply; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.StartWorkloadReply") - } - - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; - } - Ok(StartWorkloadReply { - }) - } + if !self.gateway_ipv6.is_empty() { + len += 1; } - deserializer.deserialize_struct("protect.control.v1.StartWorkloadReply", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for StartWorkloadRequest { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.workload_id.is_empty() { + if !self.gateway_mac.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.StartWorkloadRequest", len)?; - if !self.workload_id.is_empty() { - struct_ser.serialize_field("workloadId", &self.workload_id)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.NetworkReservation", len)?; + if !self.uuid.is_empty() { + struct_ser.serialize_field("uuid", &self.uuid)?; + } + if !self.ipv4.is_empty() { + struct_ser.serialize_field("ipv4", &self.ipv4)?; + } + if !self.ipv6.is_empty() { + struct_ser.serialize_field("ipv6", &self.ipv6)?; + } + if !self.mac.is_empty() { + struct_ser.serialize_field("mac", &self.mac)?; + } + if !self.gateway_ipv4.is_empty() { + struct_ser.serialize_field("gatewayIpv4", &self.gateway_ipv4)?; + } + if !self.gateway_ipv6.is_empty() { + struct_ser.serialize_field("gatewayIpv6", &self.gateway_ipv6)?; + } + if !self.gateway_mac.is_empty() { + struct_ser.serialize_field("gatewayMac", &self.gateway_mac)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for StartWorkloadRequest { +impl<'de> serde::Deserialize<'de> for NetworkReservation { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload_id", - "workloadId", + "uuid", + "ipv4", + "ipv6", + "mac", + "gateway_ipv4", + "gatewayIpv4", + "gateway_ipv6", + "gatewayIpv6", + "gateway_mac", + "gatewayMac", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WorkloadId, + Uuid, + Ipv4, + Ipv6, + Mac, + GatewayIpv4, + GatewayIpv6, + GatewayMac, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11005,7 +11067,13 @@ impl<'de> serde::Deserialize<'de> for StartWorkloadRequest { E: serde::de::Error, { match value { - "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "uuid" => Ok(GeneratedField::Uuid), + "ipv4" => Ok(GeneratedField::Ipv4), + "ipv6" => Ok(GeneratedField::Ipv6), + "mac" => Ok(GeneratedField::Mac), + "gatewayIpv4" | "gateway_ipv4" => Ok(GeneratedField::GatewayIpv4), + "gatewayIpv6" | "gateway_ipv6" => Ok(GeneratedField::GatewayIpv6), + "gatewayMac" | "gateway_mac" => Ok(GeneratedField::GatewayMac), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11015,107 +11083,158 @@ impl<'de> serde::Deserialize<'de> for StartWorkloadRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = StartWorkloadRequest; + type Value = NetworkReservation; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.StartWorkloadRequest") + formatter.write_str("struct protect.control.v1.NetworkReservation") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload_id__ = None; + let mut uuid__ = None; + let mut ipv4__ = None; + let mut ipv6__ = None; + let mut mac__ = None; + let mut gateway_ipv4__ = None; + let mut gateway_ipv6__ = None; + let mut gateway_mac__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::WorkloadId => { - if workload_id__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadId")); + GeneratedField::Uuid => { + if uuid__.is_some() { + return Err(serde::de::Error::duplicate_field("uuid")); } - workload_id__ = Some(map_.next_value()?); + uuid__ = Some(map_.next_value()?); + } + GeneratedField::Ipv4 => { + if ipv4__.is_some() { + return Err(serde::de::Error::duplicate_field("ipv4")); + } + ipv4__ = Some(map_.next_value()?); + } + GeneratedField::Ipv6 => { + if ipv6__.is_some() { + return Err(serde::de::Error::duplicate_field("ipv6")); + } + ipv6__ = Some(map_.next_value()?); + } + GeneratedField::Mac => { + if mac__.is_some() { + return Err(serde::de::Error::duplicate_field("mac")); + } + mac__ = Some(map_.next_value()?); + } + GeneratedField::GatewayIpv4 => { + if gateway_ipv4__.is_some() { + return Err(serde::de::Error::duplicate_field("gatewayIpv4")); + } + gateway_ipv4__ = Some(map_.next_value()?); + } + GeneratedField::GatewayIpv6 => { + if gateway_ipv6__.is_some() { + return Err(serde::de::Error::duplicate_field("gatewayIpv6")); + } + gateway_ipv6__ = Some(map_.next_value()?); + } + GeneratedField::GatewayMac => { + if gateway_mac__.is_some() { + return Err(serde::de::Error::duplicate_field("gatewayMac")); + } + gateway_mac__ = Some(map_.next_value()?); } } } - Ok(StartWorkloadRequest { - workload_id: workload_id__.unwrap_or_default(), + Ok(NetworkReservation { + uuid: uuid__.unwrap_or_default(), + ipv4: ipv4__.unwrap_or_default(), + ipv6: ipv6__.unwrap_or_default(), + mac: mac__.unwrap_or_default(), + gateway_ipv4: gateway_ipv4__.unwrap_or_default(), + gateway_ipv6: gateway_ipv6__.unwrap_or_default(), + gateway_mac: gateway_mac__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.StartWorkloadRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.NetworkReservation", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for StopWorkloadReply { +impl serde::Serialize for NumaStrategy { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.StopWorkloadReply", len)?; - struct_ser.end() + let variant = match self { + Self::Unspecified => "NUMA_STRATEGY_UNSPECIFIED", + Self::Compact => "NUMA_STRATEGY_COMPACT", + Self::Scatter => "NUMA_STRATEGY_SCATTER", + }; + serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for StopWorkloadReply { +impl<'de> serde::Deserialize<'de> for NumaStrategy { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "NUMA_STRATEGY_UNSPECIFIED", + "NUMA_STRATEGY_COMPACT", + "NUMA_STRATEGY_SCATTER", ]; - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; + struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = NumaStrategy; - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } + 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, - { - Err(serde::de::Error::unknown_field(value, FIELDS)) - } - } - deserializer.deserialize_identifier(GeneratedVisitor) + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = StopWorkloadReply; - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.StopWorkloadReply") + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) } - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + match value { + "NUMA_STRATEGY_UNSPECIFIED" => Ok(NumaStrategy::Unspecified), + "NUMA_STRATEGY_COMPACT" => Ok(NumaStrategy::Compact), + "NUMA_STRATEGY_SCATTER" => Ok(NumaStrategy::Scatter), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } - Ok(StopWorkloadReply { - }) } } - deserializer.deserialize_struct("protect.control.v1.StopWorkloadReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for StopWorkloadRequest { +impl serde::Serialize for ObjectCapabilityConsumeSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11123,40 +11242,37 @@ impl serde::Serialize for StopWorkloadRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.workload_id.is_empty() { + if !self.name.is_empty() { len += 1; } - if self.timeout != 0 { + if !self.provider.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.StopWorkloadRequest", len)?; - if !self.workload_id.is_empty() { - struct_ser.serialize_field("workloadId", &self.workload_id)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ObjectCapabilityConsumeSpec", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; } - if self.timeout != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("timeout", ToString::to_string(&self.timeout).as_str())?; + if !self.provider.is_empty() { + struct_ser.serialize_field("provider", &self.provider)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for StopWorkloadRequest { +impl<'de> serde::Deserialize<'de> for ObjectCapabilityConsumeSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload_id", - "workloadId", - "timeout", + "name", + "provider", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WorkloadId, - Timeout, + Name, + Provider, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11178,8 +11294,8 @@ impl<'de> serde::Deserialize<'de> for StopWorkloadRequest { E: serde::de::Error, { match value { - "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), - "timeout" => Ok(GeneratedField::Timeout), + "name" => Ok(GeneratedField::Name), + "provider" => Ok(GeneratedField::Provider), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11189,46 +11305,44 @@ impl<'de> serde::Deserialize<'de> for StopWorkloadRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = StopWorkloadRequest; + type Value = ObjectCapabilityConsumeSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.StopWorkloadRequest") + formatter.write_str("struct protect.control.v1.ObjectCapabilityConsumeSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload_id__ = None; - let mut timeout__ = None; + let mut name__ = None; + let mut provider__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::WorkloadId => { - if workload_id__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadId")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - workload_id__ = Some(map_.next_value()?); + name__ = Some(map_.next_value()?); } - GeneratedField::Timeout => { - if timeout__.is_some() { - return Err(serde::de::Error::duplicate_field("timeout")); + GeneratedField::Provider => { + if provider__.is_some() { + return Err(serde::de::Error::duplicate_field("provider")); } - timeout__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + provider__ = Some(map_.next_value()?); } } } - Ok(StopWorkloadRequest { - workload_id: workload_id__.unwrap_or_default(), - timeout: timeout__.unwrap_or_default(), + Ok(ObjectCapabilityConsumeSpec { + name: name__.unwrap_or_default(), + provider: provider__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.StopWorkloadRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ObjectCapabilityConsumeSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for TerminalSize { +impl serde::Serialize for ObjectCapabilityInfo { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11236,37 +11350,71 @@ impl serde::Serialize for TerminalSize { { use serde::ser::SerializeStruct; let mut len = 0; - if self.rows != 0 { + if !self.name.is_empty() { len += 1; } - if self.columns != 0 { + if !self.provider_zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.TerminalSize", len)?; - if self.rows != 0 { - struct_ser.serialize_field("rows", &self.rows)?; + if !self.provider_workload_id.is_empty() { + len += 1; } - if self.columns != 0 { - struct_ser.serialize_field("columns", &self.columns)?; + if self.ready { + len += 1; + } + if !self.implements.is_empty() { + len += 1; + } + if self.priority != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ObjectCapabilityInfo", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if !self.provider_zone_id.is_empty() { + struct_ser.serialize_field("providerZoneId", &self.provider_zone_id)?; + } + if !self.provider_workload_id.is_empty() { + struct_ser.serialize_field("providerWorkloadId", &self.provider_workload_id)?; + } + if self.ready { + struct_ser.serialize_field("ready", &self.ready)?; + } + if !self.implements.is_empty() { + struct_ser.serialize_field("implements", &self.implements)?; + } + if self.priority != 0 { + struct_ser.serialize_field("priority", &self.priority)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for TerminalSize { +impl<'de> serde::Deserialize<'de> for ObjectCapabilityInfo { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "rows", - "columns", + "name", + "provider_zone_id", + "providerZoneId", + "provider_workload_id", + "providerWorkloadId", + "ready", + "implements", + "priority", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Rows, - Columns, + Name, + ProviderZoneId, + ProviderWorkloadId, + Ready, + Implements, + Priority, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11288,8 +11436,12 @@ impl<'de> serde::Deserialize<'de> for TerminalSize { E: serde::de::Error, { match value { - "rows" => Ok(GeneratedField::Rows), - "columns" => Ok(GeneratedField::Columns), + "name" => Ok(GeneratedField::Name), + "providerZoneId" | "provider_zone_id" => Ok(GeneratedField::ProviderZoneId), + "providerWorkloadId" | "provider_workload_id" => Ok(GeneratedField::ProviderWorkloadId), + "ready" => Ok(GeneratedField::Ready), + "implements" => Ok(GeneratedField::Implements), + "priority" => Ok(GeneratedField::Priority), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11299,70 +11451,185 @@ impl<'de> serde::Deserialize<'de> for TerminalSize { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = TerminalSize; + type Value = ObjectCapabilityInfo; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.TerminalSize") + formatter.write_str("struct protect.control.v1.ObjectCapabilityInfo") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut rows__ = None; - let mut columns__ = None; + let mut name__ = None; + let mut provider_zone_id__ = None; + let mut provider_workload_id__ = None; + let mut ready__ = None; + let mut implements__ = None; + let mut priority__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Rows => { - if rows__.is_some() { - return Err(serde::de::Error::duplicate_field("rows")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - rows__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + name__ = Some(map_.next_value()?); } - GeneratedField::Columns => { - if columns__.is_some() { - return Err(serde::de::Error::duplicate_field("columns")); + GeneratedField::ProviderZoneId => { + if provider_zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("providerZoneId")); } - columns__ = + provider_zone_id__ = Some(map_.next_value()?); + } + GeneratedField::ProviderWorkloadId => { + if provider_workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("providerWorkloadId")); + } + provider_workload_id__ = Some(map_.next_value()?); + } + GeneratedField::Ready => { + if ready__.is_some() { + return Err(serde::de::Error::duplicate_field("ready")); + } + ready__ = Some(map_.next_value()?); + } + GeneratedField::Implements => { + if implements__.is_some() { + return Err(serde::de::Error::duplicate_field("implements")); + } + implements__ = Some(map_.next_value()?); + } + GeneratedField::Priority => { + if priority__.is_some() { + return Err(serde::de::Error::duplicate_field("priority")); + } + priority__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } } } - Ok(TerminalSize { - rows: rows__.unwrap_or_default(), - columns: columns__.unwrap_or_default(), + Ok(ObjectCapabilityInfo { + name: name__.unwrap_or_default(), + provider_zone_id: provider_zone_id__.unwrap_or_default(), + provider_workload_id: provider_workload_id__.unwrap_or_default(), + ready: ready__.unwrap_or_default(), + implements: implements__.unwrap_or_default(), + priority: priority__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.TerminalSize", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ObjectCapabilityInfo", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for UpdateZoneResourcesReply { +impl serde::Serialize for ObjectCapabilityPublishSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.UpdateZoneResourcesReply", len)?; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if !self.command.is_empty() { + len += 1; + } + if !self.environment.is_empty() { + len += 1; + } + if self.no_client_argv { + len += 1; + } + if self.no_client_env { + len += 1; + } + if self.run_as_uid.is_some() { + len += 1; + } + if self.run_as_gid.is_some() { + len += 1; + } + if !self.working_dir.is_empty() { + len += 1; + } + if !self.implements.is_empty() { + len += 1; + } + if self.priority != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ObjectCapabilityPublishSpec", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if !self.command.is_empty() { + struct_ser.serialize_field("command", &self.command)?; + } + if !self.environment.is_empty() { + struct_ser.serialize_field("environment", &self.environment)?; + } + if self.no_client_argv { + struct_ser.serialize_field("noClientArgv", &self.no_client_argv)?; + } + if self.no_client_env { + struct_ser.serialize_field("noClientEnv", &self.no_client_env)?; + } + if let Some(v) = self.run_as_uid.as_ref() { + struct_ser.serialize_field("runAsUid", v)?; + } + if let Some(v) = self.run_as_gid.as_ref() { + struct_ser.serialize_field("runAsGid", v)?; + } + if !self.working_dir.is_empty() { + struct_ser.serialize_field("workingDir", &self.working_dir)?; + } + if !self.implements.is_empty() { + struct_ser.serialize_field("implements", &self.implements)?; + } + if self.priority != 0 { + struct_ser.serialize_field("priority", &self.priority)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for UpdateZoneResourcesReply { +impl<'de> serde::Deserialize<'de> for ObjectCapabilityPublishSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "name", + "command", + "environment", + "no_client_argv", + "noClientArgv", + "no_client_env", + "noClientEnv", + "run_as_uid", + "runAsUid", + "run_as_gid", + "runAsGid", + "working_dir", + "workingDir", + "implements", + "priority", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Name, + Command, + Environment, + NoClientArgv, + NoClientEnv, + RunAsUid, + RunAsGid, + WorkingDir, + Implements, + Priority, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11383,7 +11650,19 @@ impl<'de> serde::Deserialize<'de> for UpdateZoneResourcesReply { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "name" => Ok(GeneratedField::Name), + "command" => Ok(GeneratedField::Command), + "environment" => Ok(GeneratedField::Environment), + "noClientArgv" | "no_client_argv" => Ok(GeneratedField::NoClientArgv), + "noClientEnv" | "no_client_env" => Ok(GeneratedField::NoClientEnv), + "runAsUid" | "run_as_uid" => Ok(GeneratedField::RunAsUid), + "runAsGid" | "run_as_gid" => Ok(GeneratedField::RunAsGid), + "workingDir" | "working_dir" => Ok(GeneratedField::WorkingDir), + "implements" => Ok(GeneratedField::Implements), + "priority" => Ok(GeneratedField::Priority), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -11391,66 +11670,152 @@ impl<'de> serde::Deserialize<'de> for UpdateZoneResourcesReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UpdateZoneResourcesReply; + type Value = ObjectCapabilityPublishSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.UpdateZoneResourcesReply") + formatter.write_str("struct protect.control.v1.ObjectCapabilityPublishSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; - } - Ok(UpdateZoneResourcesReply { - }) - } - } - deserializer.deserialize_struct("protect.control.v1.UpdateZoneResourcesReply", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for UpdateZoneResourcesRequest { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, + let mut name__ = None; + let mut command__ = None; + let mut environment__ = None; + let mut no_client_argv__ = None; + let mut no_client_env__ = None; + let mut run_as_uid__ = None; + let mut run_as_gid__ = None; + let mut working_dir__ = None; + let mut implements__ = None; + let mut priority__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::Command => { + if command__.is_some() { + return Err(serde::de::Error::duplicate_field("command")); + } + command__ = Some(map_.next_value()?); + } + GeneratedField::Environment => { + if environment__.is_some() { + return Err(serde::de::Error::duplicate_field("environment")); + } + environment__ = Some(map_.next_value()?); + } + GeneratedField::NoClientArgv => { + if no_client_argv__.is_some() { + return Err(serde::de::Error::duplicate_field("noClientArgv")); + } + no_client_argv__ = Some(map_.next_value()?); + } + GeneratedField::NoClientEnv => { + if no_client_env__.is_some() { + return Err(serde::de::Error::duplicate_field("noClientEnv")); + } + no_client_env__ = Some(map_.next_value()?); + } + GeneratedField::RunAsUid => { + if run_as_uid__.is_some() { + return Err(serde::de::Error::duplicate_field("runAsUid")); + } + run_as_uid__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::RunAsGid => { + if run_as_gid__.is_some() { + return Err(serde::de::Error::duplicate_field("runAsGid")); + } + run_as_gid__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::WorkingDir => { + if working_dir__.is_some() { + return Err(serde::de::Error::duplicate_field("workingDir")); + } + working_dir__ = Some(map_.next_value()?); + } + GeneratedField::Implements => { + if implements__.is_some() { + return Err(serde::de::Error::duplicate_field("implements")); + } + implements__ = Some(map_.next_value()?); + } + GeneratedField::Priority => { + if priority__.is_some() { + return Err(serde::de::Error::duplicate_field("priority")); + } + priority__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(ObjectCapabilityPublishSpec { + name: name__.unwrap_or_default(), + command: command__.unwrap_or_default(), + environment: environment__.unwrap_or_default(), + no_client_argv: no_client_argv__.unwrap_or_default(), + no_client_env: no_client_env__.unwrap_or_default(), + run_as_uid: run_as_uid__, + run_as_gid: run_as_gid__, + working_dir: working_dir__.unwrap_or_default(), + implements: implements__.unwrap_or_default(), + priority: priority__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ObjectCapabilityPublishSpec", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ObjectCapabilitySpec { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { + if !self.publishes.is_empty() { len += 1; } - if self.resources.is_some() { + if !self.consumes.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.UpdateZoneResourcesRequest", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ObjectCapabilitySpec", len)?; + if !self.publishes.is_empty() { + struct_ser.serialize_field("publishes", &self.publishes)?; } - if let Some(v) = self.resources.as_ref() { - struct_ser.serialize_field("resources", v)?; + if !self.consumes.is_empty() { + struct_ser.serialize_field("consumes", &self.consumes)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for UpdateZoneResourcesRequest { +impl<'de> serde::Deserialize<'de> for ObjectCapabilitySpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", - "resources", + "publishes", + "consumes", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, - Resources, + Publishes, + Consumes, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11472,8 +11837,8 @@ impl<'de> serde::Deserialize<'de> for UpdateZoneResourcesRequest { E: serde::de::Error, { match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - "resources" => Ok(GeneratedField::Resources), + "publishes" => Ok(GeneratedField::Publishes), + "consumes" => Ok(GeneratedField::Consumes), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11483,44 +11848,124 @@ impl<'de> serde::Deserialize<'de> for UpdateZoneResourcesRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UpdateZoneResourcesRequest; + type Value = ObjectCapabilitySpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.UpdateZoneResourcesRequest") + formatter.write_str("struct protect.control.v1.ObjectCapabilitySpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - let mut resources__ = None; + let mut publishes__ = None; + let mut consumes__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); + GeneratedField::Publishes => { + if publishes__.is_some() { + return Err(serde::de::Error::duplicate_field("publishes")); } - zone_id__ = Some(map_.next_value()?); + publishes__ = Some(map_.next_value()?); } - GeneratedField::Resources => { - if resources__.is_some() { - return Err(serde::de::Error::duplicate_field("resources")); + GeneratedField::Consumes => { + if consumes__.is_some() { + return Err(serde::de::Error::duplicate_field("consumes")); } - resources__ = map_.next_value()?; + consumes__ = Some(map_.next_value()?); } } } - Ok(UpdateZoneResourcesRequest { - zone_id: zone_id__.unwrap_or_default(), - resources: resources__, + Ok(ObjectCapabilitySpec { + publishes: publishes__.unwrap_or_default(), + consumes: consumes__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.UpdateZoneResourcesRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ObjectCapabilitySpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WatchEventsReply { +impl serde::Serialize for OciImageFormat { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "OCI_IMAGE_FORMAT_UNKNOWN", + Self::Squashfs => "OCI_IMAGE_FORMAT_SQUASHFS", + Self::Erofs => "OCI_IMAGE_FORMAT_EROFS", + Self::Tar => "OCI_IMAGE_FORMAT_TAR", + Self::Directory => "OCI_IMAGE_FORMAT_DIRECTORY", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for OciImageFormat { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "OCI_IMAGE_FORMAT_UNKNOWN", + "OCI_IMAGE_FORMAT_SQUASHFS", + "OCI_IMAGE_FORMAT_EROFS", + "OCI_IMAGE_FORMAT_TAR", + "OCI_IMAGE_FORMAT_DIRECTORY", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = OciImageFormat; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "OCI_IMAGE_FORMAT_UNKNOWN" => Ok(OciImageFormat::Unknown), + "OCI_IMAGE_FORMAT_SQUASHFS" => Ok(OciImageFormat::Squashfs), + "OCI_IMAGE_FORMAT_EROFS" => Ok(OciImageFormat::Erofs), + "OCI_IMAGE_FORMAT_TAR" => Ok(OciImageFormat::Tar), + "OCI_IMAGE_FORMAT_DIRECTORY" => Ok(OciImageFormat::Directory), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for OciImageInfo { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11528,40 +11973,64 @@ impl serde::Serialize for WatchEventsReply { { use serde::ser::SerializeStruct; let mut len = 0; - if self.event.is_some() { + if !self.digest.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WatchEventsReply", len)?; - if let Some(v) = self.event.as_ref() { - match v { - watch_events_reply::Event::ZoneChanged(v) => { - struct_ser.serialize_field("zoneChanged", v)?; - } - watch_events_reply::Event::WorkloadChanged(v) => { - struct_ser.serialize_field("workloadChanged", v)?; - } - } + if self.format != 0 { + len += 1; + } + if !self.names.is_empty() { + len += 1; + } + if self.metadata.is_some() { + len += 1; + } + if self.source_digest.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageInfo", len)?; + if !self.digest.is_empty() { + struct_ser.serialize_field("digest", &self.digest)?; + } + if self.format != 0 { + let v = OciImageFormat::try_from(self.format) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; + struct_ser.serialize_field("format", &v)?; + } + if !self.names.is_empty() { + struct_ser.serialize_field("names", &self.names)?; + } + if let Some(v) = self.metadata.as_ref() { + struct_ser.serialize_field("metadata", v)?; + } + if let Some(v) = self.source_digest.as_ref() { + struct_ser.serialize_field("sourceDigest", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WatchEventsReply { +impl<'de> serde::Deserialize<'de> for OciImageInfo { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_changed", - "zoneChanged", - "workload_changed", - "workloadChanged", + "digest", + "format", + "names", + "metadata", + "source_digest", + "sourceDigest", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneChanged, - WorkloadChanged, + Digest, + Format, + Names, + Metadata, + SourceDigest, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11583,8 +12052,11 @@ impl<'de> serde::Deserialize<'de> for WatchEventsReply { E: serde::de::Error, { match value { - "zoneChanged" | "zone_changed" => Ok(GeneratedField::ZoneChanged), - "workloadChanged" | "workload_changed" => Ok(GeneratedField::WorkloadChanged), + "digest" => Ok(GeneratedField::Digest), + "format" => Ok(GeneratedField::Format), + "names" => Ok(GeneratedField::Names), + "metadata" => Ok(GeneratedField::Metadata), + "sourceDigest" | "source_digest" => Ok(GeneratedField::SourceDigest), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11594,66 +12066,110 @@ impl<'de> serde::Deserialize<'de> for WatchEventsReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WatchEventsReply; + type Value = OciImageInfo; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WatchEventsReply") + formatter.write_str("struct protect.control.v1.OciImageInfo") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut event__ = None; + let mut digest__ = None; + let mut format__ = None; + let mut names__ = None; + let mut metadata__ = None; + let mut source_digest__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneChanged => { - if event__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneChanged")); + GeneratedField::Digest => { + if digest__.is_some() { + return Err(serde::de::Error::duplicate_field("digest")); } - event__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_events_reply::Event::ZoneChanged) -; + digest__ = Some(map_.next_value()?); } - GeneratedField::WorkloadChanged => { - if event__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadChanged")); - } - event__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_events_reply::Event::WorkloadChanged) -; + GeneratedField::Format => { + if format__.is_some() { + return Err(serde::de::Error::duplicate_field("format")); + } + format__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Names => { + if names__.is_some() { + return Err(serde::de::Error::duplicate_field("names")); + } + names__ = Some(map_.next_value()?); + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = map_.next_value()?; + } + GeneratedField::SourceDigest => { + if source_digest__.is_some() { + return Err(serde::de::Error::duplicate_field("sourceDigest")); + } + source_digest__ = map_.next_value()?; } } } - Ok(WatchEventsReply { - event: event__, + Ok(OciImageInfo { + digest: digest__.unwrap_or_default(), + format: format__.unwrap_or_default(), + names: names__.unwrap_or_default(), + metadata: metadata__, + source_digest: source_digest__, }) } } - deserializer.deserialize_struct("protect.control.v1.WatchEventsReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageInfo", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WatchEventsRequest { +impl serde::Serialize for OciImageMetadata { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.WatchEventsRequest", len)?; + let mut len = 0; + if !self.manifest.is_empty() { + len += 1; + } + if !self.config.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageMetadata", len)?; + if !self.manifest.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("manifest", pbjson::private::base64::encode(&self.manifest).as_str())?; + } + if !self.config.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("config", pbjson::private::base64::encode(&self.config).as_str())?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WatchEventsRequest { +impl<'de> serde::Deserialize<'de> for OciImageMetadata { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "manifest", + "config", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Manifest, + Config, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11674,7 +12190,11 @@ impl<'de> serde::Deserialize<'de> for WatchEventsRequest { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "manifest" => Ok(GeneratedField::Manifest), + "config" => Ok(GeneratedField::Config), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -11682,27 +12202,48 @@ impl<'de> serde::Deserialize<'de> for WatchEventsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WatchEventsRequest; + type Value = OciImageMetadata; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WatchEventsRequest") + formatter.write_str("struct protect.control.v1.OciImageMetadata") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut manifest__ = None; + let mut config__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Manifest => { + if manifest__.is_some() { + return Err(serde::de::Error::duplicate_field("manifest")); + } + manifest__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Config => { + if config__.is_some() { + return Err(serde::de::Error::duplicate_field("config")); + } + config__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } } - Ok(WatchEventsRequest { + Ok(OciImageMetadata { + manifest: manifest__.unwrap_or_default(), + config: config__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.WatchEventsRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageMetadata", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Workload { +impl serde::Serialize for OciImageProgress { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11710,45 +12251,47 @@ impl serde::Serialize for Workload { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.id.is_empty() { + if self.phase != 0 { len += 1; } - if self.spec.is_some() { + if !self.layers.is_empty() { len += 1; } - if self.status.is_some() { + if self.indication.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.Workload", len)?; - if !self.id.is_empty() { - struct_ser.serialize_field("id", &self.id)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgress", len)?; + if self.phase != 0 { + let v = OciImageProgressPhase::try_from(self.phase) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.phase)))?; + struct_ser.serialize_field("phase", &v)?; } - if let Some(v) = self.spec.as_ref() { - struct_ser.serialize_field("spec", v)?; + if !self.layers.is_empty() { + struct_ser.serialize_field("layers", &self.layers)?; } - if let Some(v) = self.status.as_ref() { - struct_ser.serialize_field("status", v)?; + if let Some(v) = self.indication.as_ref() { + struct_ser.serialize_field("indication", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Workload { +impl<'de> serde::Deserialize<'de> for OciImageProgress { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "id", - "spec", - "status", + "phase", + "layers", + "indication", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Id, - Spec, - Status, + Phase, + Layers, + Indication, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11770,9 +12313,9 @@ impl<'de> serde::Deserialize<'de> for Workload { E: serde::de::Error, { match value { - "id" => Ok(GeneratedField::Id), - "spec" => Ok(GeneratedField::Spec), - "status" => Ok(GeneratedField::Status), + "phase" => Ok(GeneratedField::Phase), + "layers" => Ok(GeneratedField::Layers), + "indication" => Ok(GeneratedField::Indication), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11782,52 +12325,52 @@ impl<'de> serde::Deserialize<'de> for Workload { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Workload; + type Value = OciImageProgress; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.Workload") + formatter.write_str("struct protect.control.v1.OciImageProgress") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut id__ = None; - let mut spec__ = None; - let mut status__ = None; + let mut phase__ = None; + let mut layers__ = None; + let mut indication__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Id => { - if id__.is_some() { - return Err(serde::de::Error::duplicate_field("id")); + GeneratedField::Phase => { + if phase__.is_some() { + return Err(serde::de::Error::duplicate_field("phase")); } - id__ = Some(map_.next_value()?); + phase__ = Some(map_.next_value::()? as i32); } - GeneratedField::Spec => { - if spec__.is_some() { - return Err(serde::de::Error::duplicate_field("spec")); + GeneratedField::Layers => { + if layers__.is_some() { + return Err(serde::de::Error::duplicate_field("layers")); } - spec__ = map_.next_value()?; + layers__ = Some(map_.next_value()?); } - GeneratedField::Status => { - if status__.is_some() { - return Err(serde::de::Error::duplicate_field("status")); + GeneratedField::Indication => { + if indication__.is_some() { + return Err(serde::de::Error::duplicate_field("indication")); } - status__ = map_.next_value()?; + indication__ = map_.next_value()?; } } } - Ok(Workload { - id: id__.unwrap_or_default(), - spec: spec__, - status: status__, + Ok(OciImageProgress { + phase: phase__.unwrap_or_default(), + layers: layers__.unwrap_or_default(), + indication: indication__, }) } } - deserializer.deserialize_struct("protect.control.v1.Workload", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageProgress", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadBlockDeviceInfo { +impl serde::Serialize for OciImageProgressIndication { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11835,58 +12378,48 @@ impl serde::Serialize for WorkloadBlockDeviceInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if self.block_index != 0 { - len += 1; - } - if self.device_id != 0 { - len += 1; - } - if !self.device.is_empty() { - len += 1; - } - if self.loop_dev { + if self.indication.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadBlockDeviceInfo", len)?; - if self.block_index != 0 { - struct_ser.serialize_field("blockIndex", &self.block_index)?; - } - if self.device_id != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("deviceId", ToString::to_string(&self.device_id).as_str())?; - } - if !self.device.is_empty() { - struct_ser.serialize_field("device", &self.device)?; - } - if self.loop_dev { - struct_ser.serialize_field("loopDev", &self.loop_dev)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndication", len)?; + if let Some(v) = self.indication.as_ref() { + match v { + oci_image_progress_indication::Indication::Bar(v) => { + struct_ser.serialize_field("bar", v)?; + } + oci_image_progress_indication::Indication::Spinner(v) => { + struct_ser.serialize_field("spinner", v)?; + } + oci_image_progress_indication::Indication::Hidden(v) => { + struct_ser.serialize_field("hidden", v)?; + } + oci_image_progress_indication::Indication::Completed(v) => { + struct_ser.serialize_field("completed", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceInfo { +impl<'de> serde::Deserialize<'de> for OciImageProgressIndication { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "block_index", - "blockIndex", - "device_id", - "deviceId", - "device", - "loop_dev", - "loopDev", + "bar", + "spinner", + "hidden", + "completed", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - BlockIndex, - DeviceId, - Device, - LoopDev, + Bar, + Spinner, + Hidden, + Completed, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11908,10 +12441,10 @@ impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceInfo { E: serde::de::Error, { match value { - "blockIndex" | "block_index" => Ok(GeneratedField::BlockIndex), - "deviceId" | "device_id" => Ok(GeneratedField::DeviceId), - "device" => Ok(GeneratedField::Device), - "loopDev" | "loop_dev" => Ok(GeneratedField::LoopDev), + "bar" => Ok(GeneratedField::Bar), + "spinner" => Ok(GeneratedField::Spinner), + "hidden" => Ok(GeneratedField::Hidden), + "completed" => Ok(GeneratedField::Completed), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11921,64 +12454,58 @@ impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadBlockDeviceInfo; + type Value = OciImageProgressIndication; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadBlockDeviceInfo") + formatter.write_str("struct protect.control.v1.OciImageProgressIndication") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut block_index__ = None; - let mut device_id__ = None; - let mut device__ = None; - let mut loop_dev__ = None; + let mut indication__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::BlockIndex => { - if block_index__.is_some() { - return Err(serde::de::Error::duplicate_field("blockIndex")); + GeneratedField::Bar => { + if indication__.is_some() { + return Err(serde::de::Error::duplicate_field("bar")); } - block_index__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + indication__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_image_progress_indication::Indication::Bar) +; } - GeneratedField::DeviceId => { - if device_id__.is_some() { - return Err(serde::de::Error::duplicate_field("deviceId")); + GeneratedField::Spinner => { + if indication__.is_some() { + return Err(serde::de::Error::duplicate_field("spinner")); } - device_id__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + indication__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_image_progress_indication::Indication::Spinner) +; } - GeneratedField::Device => { - if device__.is_some() { - return Err(serde::de::Error::duplicate_field("device")); + GeneratedField::Hidden => { + if indication__.is_some() { + return Err(serde::de::Error::duplicate_field("hidden")); } - device__ = Some(map_.next_value()?); + indication__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_image_progress_indication::Indication::Hidden) +; } - GeneratedField::LoopDev => { - if loop_dev__.is_some() { - return Err(serde::de::Error::duplicate_field("loopDev")); + GeneratedField::Completed => { + if indication__.is_some() { + return Err(serde::de::Error::duplicate_field("completed")); } - loop_dev__ = Some(map_.next_value()?); + indication__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_image_progress_indication::Indication::Completed) +; } } } - Ok(WorkloadBlockDeviceInfo { - block_index: block_index__.unwrap_or_default(), - device_id: device_id__.unwrap_or_default(), - device: device__.unwrap_or_default(), - loop_dev: loop_dev__.unwrap_or_default(), + Ok(OciImageProgressIndication { + indication: indication__, }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadBlockDeviceInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndication", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadBlockDeviceSpec { +impl serde::Serialize for OciImageProgressIndicationBar { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11986,48 +12513,58 @@ impl serde::Serialize for WorkloadBlockDeviceSpec { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.target_path.is_empty() { + if !self.message.is_empty() { len += 1; } - if !self.device_path.is_empty() { + if self.current != 0 { len += 1; } - if self.mount_options.is_some() { + if self.total != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadBlockDeviceSpec", len)?; - if !self.target_path.is_empty() { - struct_ser.serialize_field("targetPath", &self.target_path)?; + if self.is_bytes { + len += 1; } - if !self.device_path.is_empty() { - struct_ser.serialize_field("devicePath", &self.device_path)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndicationBar", len)?; + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; } - if let Some(v) = self.mount_options.as_ref() { - struct_ser.serialize_field("mountOptions", v)?; + if self.current != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("current", ToString::to_string(&self.current).as_str())?; + } + if self.total != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("total", ToString::to_string(&self.total).as_str())?; + } + if self.is_bytes { + struct_ser.serialize_field("isBytes", &self.is_bytes)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceSpec { +impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationBar { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "target_path", - "targetPath", - "device_path", - "devicePath", - "mount_options", - "mountOptions", + "message", + "current", + "total", + "is_bytes", + "isBytes", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - TargetPath, - DevicePath, - MountOptions, + Message, + Current, + Total, + IsBytes, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -12049,9 +12586,10 @@ impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceSpec { E: serde::de::Error, { match value { - "targetPath" | "target_path" => Ok(GeneratedField::TargetPath), - "devicePath" | "device_path" => Ok(GeneratedField::DevicePath), - "mountOptions" | "mount_options" => Ok(GeneratedField::MountOptions), + "message" => Ok(GeneratedField::Message), + "current" => Ok(GeneratedField::Current), + "total" => Ok(GeneratedField::Total), + "isBytes" | "is_bytes" => Ok(GeneratedField::IsBytes), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -12061,52 +12599,64 @@ impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadBlockDeviceSpec; + type Value = OciImageProgressIndicationBar; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadBlockDeviceSpec") + formatter.write_str("struct protect.control.v1.OciImageProgressIndicationBar") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut target_path__ = None; - let mut device_path__ = None; - let mut mount_options__ = None; + let mut message__ = None; + let mut current__ = None; + let mut total__ = None; + let mut is_bytes__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::TargetPath => { - if target_path__.is_some() { - return Err(serde::de::Error::duplicate_field("targetPath")); + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); } - target_path__ = Some(map_.next_value()?); + message__ = Some(map_.next_value()?); } - GeneratedField::DevicePath => { - if device_path__.is_some() { - return Err(serde::de::Error::duplicate_field("devicePath")); + GeneratedField::Current => { + if current__.is_some() { + return Err(serde::de::Error::duplicate_field("current")); } - device_path__ = Some(map_.next_value()?); + current__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::MountOptions => { - if mount_options__.is_some() { - return Err(serde::de::Error::duplicate_field("mountOptions")); + GeneratedField::Total => { + if total__.is_some() { + return Err(serde::de::Error::duplicate_field("total")); } - mount_options__ = map_.next_value()?; + total__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::IsBytes => { + if is_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("isBytes")); + } + is_bytes__ = Some(map_.next_value()?); } } } - Ok(WorkloadBlockDeviceSpec { - target_path: target_path__.unwrap_or_default(), - device_path: device_path__.unwrap_or_default(), - mount_options: mount_options__, + Ok(OciImageProgressIndicationBar { + message: message__.unwrap_or_default(), + current: current__.unwrap_or_default(), + total: total__.unwrap_or_default(), + is_bytes: is_bytes__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadBlockDeviceSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndicationBar", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadBlockDeviceStatus { +impl serde::Serialize for OciImageProgressIndicationCompleted { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -12114,29 +12664,48 @@ impl serde::Serialize for WorkloadBlockDeviceStatus { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.devices.is_empty() { + if !self.message.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadBlockDeviceStatus", len)?; - if !self.devices.is_empty() { - struct_ser.serialize_field("devices", &self.devices)?; + if self.total != 0 { + len += 1; + } + if self.is_bytes { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndicationCompleted", len)?; + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; + } + if self.total != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("total", ToString::to_string(&self.total).as_str())?; + } + if self.is_bytes { + struct_ser.serialize_field("isBytes", &self.is_bytes)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceStatus { +impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationCompleted { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "devices", + "message", + "total", + "is_bytes", + "isBytes", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Devices, + Message, + Total, + IsBytes, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -12158,7 +12727,9 @@ impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceStatus { E: serde::de::Error, { match value { - "devices" => Ok(GeneratedField::Devices), + "message" => Ok(GeneratedField::Message), + "total" => Ok(GeneratedField::Total), + "isBytes" | "is_bytes" => Ok(GeneratedField::IsBytes), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -12168,66 +12739,76 @@ impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadBlockDeviceStatus; + type Value = OciImageProgressIndicationCompleted; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadBlockDeviceStatus") + formatter.write_str("struct protect.control.v1.OciImageProgressIndicationCompleted") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut devices__ = None; + let mut message__ = None; + let mut total__ = None; + let mut is_bytes__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Devices => { - if devices__.is_some() { - return Err(serde::de::Error::duplicate_field("devices")); + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); } - devices__ = Some(map_.next_value()?); + message__ = Some(map_.next_value()?); + } + GeneratedField::Total => { + if total__.is_some() { + return Err(serde::de::Error::duplicate_field("total")); + } + total__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::IsBytes => { + if is_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("isBytes")); + } + is_bytes__ = Some(map_.next_value()?); } } } - Ok(WorkloadBlockDeviceStatus { - devices: devices__.unwrap_or_default(), - }) - } + Ok(OciImageProgressIndicationCompleted { + message: message__.unwrap_or_default(), + total: total__.unwrap_or_default(), + is_bytes: is_bytes__.unwrap_or_default(), + }) + } } - deserializer.deserialize_struct("protect.control.v1.WorkloadBlockDeviceStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndicationCompleted", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadChangedEvent { +impl serde::Serialize for OciImageProgressIndicationHidden { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if self.workload.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadChangedEvent", len)?; - if let Some(v) = self.workload.as_ref() { - struct_ser.serialize_field("workload", v)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndicationHidden", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadChangedEvent { +impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationHidden { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Workload, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -12248,10 +12829,7 @@ impl<'de> serde::Deserialize<'de> for WorkloadChangedEvent { where E: serde::de::Error, { - match value { - "workload" => Ok(GeneratedField::Workload), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -12259,36 +12837,27 @@ impl<'de> serde::Deserialize<'de> for WorkloadChangedEvent { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadChangedEvent; + type Value = OciImageProgressIndicationHidden; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadChangedEvent") + formatter.write_str("struct protect.control.v1.OciImageProgressIndicationHidden") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Workload => { - if workload__.is_some() { - return Err(serde::de::Error::duplicate_field("workload")); - } - workload__ = map_.next_value()?; - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(WorkloadChangedEvent { - workload: workload__, + Ok(OciImageProgressIndicationHidden { }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadChangedEvent", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndicationHidden", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadConsoleReply { +impl serde::Serialize for OciImageProgressIndicationSpinner { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -12296,41 +12865,29 @@ impl serde::Serialize for WorkloadConsoleReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.stdout.is_empty() { - len += 1; - } - if !self.stderr.is_empty() { + if !self.message.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadConsoleReply", len)?; - if !self.stdout.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("stdout", pbjson::private::base64::encode(&self.stdout).as_str())?; - } - if !self.stderr.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("stderr", pbjson::private::base64::encode(&self.stderr).as_str())?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressIndicationSpinner", len)?; + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadConsoleReply { +impl<'de> serde::Deserialize<'de> for OciImageProgressIndicationSpinner { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "stdout", - "stderr", + "message", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Stdout, - Stderr, + Message, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -12352,8 +12909,7 @@ impl<'de> serde::Deserialize<'de> for WorkloadConsoleReply { E: serde::de::Error, { match value { - "stdout" => Ok(GeneratedField::Stdout), - "stderr" => Ok(GeneratedField::Stderr), + "message" => Ok(GeneratedField::Message), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -12363,48 +12919,36 @@ impl<'de> serde::Deserialize<'de> for WorkloadConsoleReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadConsoleReply; + type Value = OciImageProgressIndicationSpinner; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadConsoleReply") + formatter.write_str("struct protect.control.v1.OciImageProgressIndicationSpinner") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut stdout__ = None; - let mut stderr__ = None; + let mut message__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Stdout => { - if stdout__.is_some() { - return Err(serde::de::Error::duplicate_field("stdout")); - } - stdout__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::Stderr => { - if stderr__.is_some() { - return Err(serde::de::Error::duplicate_field("stderr")); + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); } - stderr__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + message__ = Some(map_.next_value()?); } } } - Ok(WorkloadConsoleReply { - stdout: stdout__.unwrap_or_default(), - stderr: stderr__.unwrap_or_default(), + Ok(OciImageProgressIndicationSpinner { + message: message__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadConsoleReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageProgressIndicationSpinner", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadConsoleRequest { +impl serde::Serialize for OciImageProgressLayer { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -12412,58 +12956,47 @@ impl serde::Serialize for WorkloadConsoleRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.workload_id.is_empty() { - len += 1; - } - if !self.stdin.is_empty() { + if !self.id.is_empty() { len += 1; } - if self.stdin_closed { + if self.phase != 0 { len += 1; } - if self.terminal_resize.is_some() { + if self.indication.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadConsoleRequest", len)?; - if !self.workload_id.is_empty() { - struct_ser.serialize_field("workloadId", &self.workload_id)?; - } - if !self.stdin.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("stdin", pbjson::private::base64::encode(&self.stdin).as_str())?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageProgressLayer", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; } - if self.stdin_closed { - struct_ser.serialize_field("stdinClosed", &self.stdin_closed)?; + if self.phase != 0 { + let v = OciImageProgressLayerPhase::try_from(self.phase) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.phase)))?; + struct_ser.serialize_field("phase", &v)?; } - if let Some(v) = self.terminal_resize.as_ref() { - struct_ser.serialize_field("terminalResize", v)?; + if let Some(v) = self.indication.as_ref() { + struct_ser.serialize_field("indication", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadConsoleRequest { +impl<'de> serde::Deserialize<'de> for OciImageProgressLayer { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "workload_id", - "workloadId", - "stdin", - "stdin_closed", - "stdinClosed", - "terminal_resize", - "terminalResize", + "id", + "phase", + "indication", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - WorkloadId, - Stdin, - StdinClosed, - TerminalResize, + Id, + Phase, + Indication, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -12485,10 +13018,9 @@ impl<'de> serde::Deserialize<'de> for WorkloadConsoleRequest { E: serde::de::Error, { match value { - "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), - "stdin" => Ok(GeneratedField::Stdin), - "stdinClosed" | "stdin_closed" => Ok(GeneratedField::StdinClosed), - "terminalResize" | "terminal_resize" => Ok(GeneratedField::TerminalResize), + "id" => Ok(GeneratedField::Id), + "phase" => Ok(GeneratedField::Phase), + "indication" => Ok(GeneratedField::Indication), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -12498,153 +13030,227 @@ impl<'de> serde::Deserialize<'de> for WorkloadConsoleRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadConsoleRequest; + type Value = OciImageProgressLayer; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadConsoleRequest") + formatter.write_str("struct protect.control.v1.OciImageProgressLayer") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut workload_id__ = None; - let mut stdin__ = None; - let mut stdin_closed__ = None; - let mut terminal_resize__ = None; + let mut id__ = None; + let mut phase__ = None; + let mut indication__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::WorkloadId => { - if workload_id__.is_some() { - return Err(serde::de::Error::duplicate_field("workloadId")); - } - workload_id__ = Some(map_.next_value()?); - } - GeneratedField::Stdin => { - if stdin__.is_some() { - return Err(serde::de::Error::duplicate_field("stdin")); + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); } - stdin__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + id__ = Some(map_.next_value()?); } - GeneratedField::StdinClosed => { - if stdin_closed__.is_some() { - return Err(serde::de::Error::duplicate_field("stdinClosed")); + GeneratedField::Phase => { + if phase__.is_some() { + return Err(serde::de::Error::duplicate_field("phase")); } - stdin_closed__ = Some(map_.next_value()?); + phase__ = Some(map_.next_value::()? as i32); } - GeneratedField::TerminalResize => { - if terminal_resize__.is_some() { - return Err(serde::de::Error::duplicate_field("terminalResize")); + GeneratedField::Indication => { + if indication__.is_some() { + return Err(serde::de::Error::duplicate_field("indication")); } - terminal_resize__ = map_.next_value()?; + indication__ = map_.next_value()?; } } } - Ok(WorkloadConsoleRequest { - workload_id: workload_id__.unwrap_or_default(), - stdin: stdin__.unwrap_or_default(), - stdin_closed: stdin_closed__.unwrap_or_default(), - terminal_resize: terminal_resize__, + Ok(OciImageProgressLayer { + id: id__.unwrap_or_default(), + phase: phase__.unwrap_or_default(), + indication: indication__, }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadConsoleRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageProgressLayer", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadErrorStatus { +impl serde::Serialize for OciImageProgressLayerPhase { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.message.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadErrorStatus", len)?; - if !self.message.is_empty() { - struct_ser.serialize_field("message", &self.message)?; - } - struct_ser.end() + let variant = match self { + Self::Unknown => "OCI_IMAGE_PROGRESS_LAYER_PHASE_UNKNOWN", + Self::Waiting => "OCI_IMAGE_PROGRESS_LAYER_PHASE_WAITING", + Self::Downloading => "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADING", + Self::Downloaded => "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADED", + Self::Extracting => "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTING", + Self::Extracted => "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTED", + }; + serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for WorkloadErrorStatus { +impl<'de> serde::Deserialize<'de> for OciImageProgressLayerPhase { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "message", - ]; + "OCI_IMAGE_PROGRESS_LAYER_PHASE_UNKNOWN", + "OCI_IMAGE_PROGRESS_LAYER_PHASE_WAITING", + "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADING", + "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADED", + "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTING", + "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTED", + ]; - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Message, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = OciImageProgressLayerPhase; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result where - D: serde::Deserializer<'de>, + E: serde::de::Error, { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "message" => Ok(GeneratedField::Message), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "OCI_IMAGE_PROGRESS_LAYER_PHASE_UNKNOWN" => Ok(OciImageProgressLayerPhase::Unknown), + "OCI_IMAGE_PROGRESS_LAYER_PHASE_WAITING" => Ok(OciImageProgressLayerPhase::Waiting), + "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADING" => Ok(OciImageProgressLayerPhase::Downloading), + "OCI_IMAGE_PROGRESS_LAYER_PHASE_DOWNLOADED" => Ok(OciImageProgressLayerPhase::Downloaded), + "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTING" => Ok(OciImageProgressLayerPhase::Extracting), + "OCI_IMAGE_PROGRESS_LAYER_PHASE_EXTRACTED" => Ok(OciImageProgressLayerPhase::Extracted), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } - deserializer.deserialize_identifier(GeneratedVisitor) } } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for OciImageProgressPhase { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "OCI_IMAGE_PROGRESS_PHASE_UNKNOWN", + Self::Started => "OCI_IMAGE_PROGRESS_PHASE_STARTED", + Self::Resolving => "OCI_IMAGE_PROGRESS_PHASE_RESOLVING", + Self::Resolved => "OCI_IMAGE_PROGRESS_PHASE_RESOLVED", + Self::ConfigDownload => "OCI_IMAGE_PROGRESS_PHASE_CONFIG_DOWNLOAD", + Self::LayerDownload => "OCI_IMAGE_PROGRESS_PHASE_LAYER_DOWNLOAD", + Self::Assemble => "OCI_IMAGE_PROGRESS_PHASE_ASSEMBLE", + Self::Pack => "OCI_IMAGE_PROGRESS_PHASE_PACK", + Self::Complete => "OCI_IMAGE_PROGRESS_PHASE_COMPLETE", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for OciImageProgressPhase { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "OCI_IMAGE_PROGRESS_PHASE_UNKNOWN", + "OCI_IMAGE_PROGRESS_PHASE_STARTED", + "OCI_IMAGE_PROGRESS_PHASE_RESOLVING", + "OCI_IMAGE_PROGRESS_PHASE_RESOLVED", + "OCI_IMAGE_PROGRESS_PHASE_CONFIG_DOWNLOAD", + "OCI_IMAGE_PROGRESS_PHASE_LAYER_DOWNLOAD", + "OCI_IMAGE_PROGRESS_PHASE_ASSEMBLE", + "OCI_IMAGE_PROGRESS_PHASE_PACK", + "OCI_IMAGE_PROGRESS_PHASE_COMPLETE", + ]; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadErrorStatus; + type Value = OciImageProgressPhase; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadErrorStatus") + write!(formatter, "expected one of: {:?}", &FIELDS) } - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, { - let mut message__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Message => { - if message__.is_some() { - return Err(serde::de::Error::duplicate_field("message")); - } - message__ = Some(map_.next_value()?); - } - } + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "OCI_IMAGE_PROGRESS_PHASE_UNKNOWN" => Ok(OciImageProgressPhase::Unknown), + "OCI_IMAGE_PROGRESS_PHASE_STARTED" => Ok(OciImageProgressPhase::Started), + "OCI_IMAGE_PROGRESS_PHASE_RESOLVING" => Ok(OciImageProgressPhase::Resolving), + "OCI_IMAGE_PROGRESS_PHASE_RESOLVED" => Ok(OciImageProgressPhase::Resolved), + "OCI_IMAGE_PROGRESS_PHASE_CONFIG_DOWNLOAD" => Ok(OciImageProgressPhase::ConfigDownload), + "OCI_IMAGE_PROGRESS_PHASE_LAYER_DOWNLOAD" => Ok(OciImageProgressPhase::LayerDownload), + "OCI_IMAGE_PROGRESS_PHASE_ASSEMBLE" => Ok(OciImageProgressPhase::Assemble), + "OCI_IMAGE_PROGRESS_PHASE_PACK" => Ok(OciImageProgressPhase::Pack), + "OCI_IMAGE_PROGRESS_PHASE_COMPLETE" => Ok(OciImageProgressPhase::Complete), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } - Ok(WorkloadErrorStatus { - message: message__.unwrap_or_default(), - }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadErrorStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for WorkloadExitStatus { +impl serde::Serialize for OciImageSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -12652,29 +13258,39 @@ impl serde::Serialize for WorkloadExitStatus { { use serde::ser::SerializeStruct; let mut len = 0; - if self.code != 0 { + if !self.digest.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadExitStatus", len)?; - if self.code != 0 { - struct_ser.serialize_field("code", &self.code)?; + if self.format != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciImageSpec", len)?; + if !self.digest.is_empty() { + struct_ser.serialize_field("digest", &self.digest)?; + } + if self.format != 0 { + let v = OciImageFormat::try_from(self.format) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; + struct_ser.serialize_field("format", &v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadExitStatus { +impl<'de> serde::Deserialize<'de> for OciImageSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "code", + "digest", + "format", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Code, + Digest, + Format, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -12696,7 +13312,8 @@ impl<'de> serde::Deserialize<'de> for WorkloadExitStatus { E: serde::de::Error, { match value { - "code" => Ok(GeneratedField::Code), + "digest" => Ok(GeneratedField::Digest), + "format" => Ok(GeneratedField::Format), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -12706,38 +13323,44 @@ impl<'de> serde::Deserialize<'de> for WorkloadExitStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadExitStatus; + type Value = OciImageSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadExitStatus") + formatter.write_str("struct protect.control.v1.OciImageSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut code__ = None; + let mut digest__ = None; + let mut format__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Code => { - if code__.is_some() { - return Err(serde::de::Error::duplicate_field("code")); + GeneratedField::Digest => { + if digest__.is_some() { + return Err(serde::de::Error::duplicate_field("digest")); } - code__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + digest__ = Some(map_.next_value()?); + } + GeneratedField::Format => { + if format__.is_some() { + return Err(serde::de::Error::duplicate_field("format")); + } + format__ = Some(map_.next_value::()? as i32); } } } - Ok(WorkloadExitStatus { - code: code__.unwrap_or_default(), + Ok(OciImageSpec { + digest: digest__.unwrap_or_default(), + format: format__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadExitStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciImageSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadMountInfo { +impl serde::Serialize for OciRegistryAuthentication { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -12745,47 +13368,52 @@ impl serde::Serialize for WorkloadMountInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.tag.is_empty() { - len += 1; - } - if !self.host_path.is_empty() { - len += 1; - } - if !self.target_path.is_empty() { + if self.authentication_method.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadMountInfo", len)?; - if !self.tag.is_empty() { - struct_ser.serialize_field("tag", &self.tag)?; - } - if !self.host_path.is_empty() { - struct_ser.serialize_field("hostPath", &self.host_path)?; - } - if !self.target_path.is_empty() { - struct_ser.serialize_field("targetPath", &self.target_path)?; - } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciRegistryAuthentication", len)?; + if let Some(v) = self.authentication_method.as_ref() { + match v { + oci_registry_authentication::AuthenticationMethod::UsernamePassword(v) => { + struct_ser.serialize_field("usernamePassword", v)?; + } + oci_registry_authentication::AuthenticationMethod::RawBasicAuth(v) => { + struct_ser.serialize_field("rawBasicAuth", v)?; + } + oci_registry_authentication::AuthenticationMethod::IdentityToken(v) => { + struct_ser.serialize_field("identityToken", v)?; + } + oci_registry_authentication::AuthenticationMethod::RegistryToken(v) => { + struct_ser.serialize_field("registryToken", v)?; + } + } + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadMountInfo { +impl<'de> serde::Deserialize<'de> for OciRegistryAuthentication { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "tag", - "host_path", - "hostPath", - "target_path", - "targetPath", + "username_password", + "usernamePassword", + "raw_basic_auth", + "rawBasicAuth", + "identity_token", + "identityToken", + "registry_token", + "registryToken", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Tag, - HostPath, - TargetPath, + UsernamePassword, + RawBasicAuth, + IdentityToken, + RegistryToken, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -12807,9 +13435,10 @@ impl<'de> serde::Deserialize<'de> for WorkloadMountInfo { E: serde::de::Error, { match value { - "tag" => Ok(GeneratedField::Tag), - "hostPath" | "host_path" => Ok(GeneratedField::HostPath), - "targetPath" | "target_path" => Ok(GeneratedField::TargetPath), + "usernamePassword" | "username_password" => Ok(GeneratedField::UsernamePassword), + "rawBasicAuth" | "raw_basic_auth" => Ok(GeneratedField::RawBasicAuth), + "identityToken" | "identity_token" => Ok(GeneratedField::IdentityToken), + "registryToken" | "registry_token" => Ok(GeneratedField::RegistryToken), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -12819,52 +13448,55 @@ impl<'de> serde::Deserialize<'de> for WorkloadMountInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadMountInfo; + type Value = OciRegistryAuthentication; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadMountInfo") + formatter.write_str("struct protect.control.v1.OciRegistryAuthentication") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut tag__ = None; - let mut host_path__ = None; - let mut target_path__ = None; + let mut authentication_method__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Tag => { - if tag__.is_some() { - return Err(serde::de::Error::duplicate_field("tag")); + GeneratedField::UsernamePassword => { + if authentication_method__.is_some() { + return Err(serde::de::Error::duplicate_field("usernamePassword")); } - tag__ = Some(map_.next_value()?); + authentication_method__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_registry_authentication::AuthenticationMethod::UsernamePassword) +; } - GeneratedField::HostPath => { - if host_path__.is_some() { - return Err(serde::de::Error::duplicate_field("hostPath")); + GeneratedField::RawBasicAuth => { + if authentication_method__.is_some() { + return Err(serde::de::Error::duplicate_field("rawBasicAuth")); } - host_path__ = Some(map_.next_value()?); + authentication_method__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_registry_authentication::AuthenticationMethod::RawBasicAuth); } - GeneratedField::TargetPath => { - if target_path__.is_some() { - return Err(serde::de::Error::duplicate_field("targetPath")); + GeneratedField::IdentityToken => { + if authentication_method__.is_some() { + return Err(serde::de::Error::duplicate_field("identityToken")); } - target_path__ = Some(map_.next_value()?); + authentication_method__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_registry_authentication::AuthenticationMethod::IdentityToken); + } + GeneratedField::RegistryToken => { + if authentication_method__.is_some() { + return Err(serde::de::Error::duplicate_field("registryToken")); + } + authentication_method__ = map_.next_value::<::std::option::Option<_>>()?.map(oci_registry_authentication::AuthenticationMethod::RegistryToken); } } } - Ok(WorkloadMountInfo { - tag: tag__.unwrap_or_default(), - host_path: host_path__.unwrap_or_default(), - target_path: target_path__.unwrap_or_default(), + Ok(OciRegistryAuthentication { + authentication_method: authentication_method__, }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadMountInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciRegistryAuthentication", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadMountStatus { +impl serde::Serialize for OciRegistryUsernamePassword { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -12872,29 +13504,37 @@ impl serde::Serialize for WorkloadMountStatus { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.mounts.is_empty() { + if !self.username.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadMountStatus", len)?; - if !self.mounts.is_empty() { - struct_ser.serialize_field("mounts", &self.mounts)?; + if !self.password.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.OciRegistryUsernamePassword", len)?; + if !self.username.is_empty() { + struct_ser.serialize_field("username", &self.username)?; + } + if !self.password.is_empty() { + struct_ser.serialize_field("password", &self.password)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadMountStatus { +impl<'de> serde::Deserialize<'de> for OciRegistryUsernamePassword { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "mounts", + "username", + "password", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Mounts, + Username, + Password, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -12916,7 +13556,8 @@ impl<'de> serde::Deserialize<'de> for WorkloadMountStatus { E: serde::de::Error, { match value { - "mounts" => Ok(GeneratedField::Mounts), + "username" => Ok(GeneratedField::Username), + "password" => Ok(GeneratedField::Password), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -12926,157 +13567,246 @@ impl<'de> serde::Deserialize<'de> for WorkloadMountStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadMountStatus; + type Value = OciRegistryUsernamePassword; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadMountStatus") + formatter.write_str("struct protect.control.v1.OciRegistryUsernamePassword") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut mounts__ = None; + let mut username__ = None; + let mut password__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Mounts => { - if mounts__.is_some() { - return Err(serde::de::Error::duplicate_field("mounts")); + GeneratedField::Username => { + if username__.is_some() { + return Err(serde::de::Error::duplicate_field("username")); } - mounts__ = Some(map_.next_value()?); + username__ = Some(map_.next_value()?); + } + GeneratedField::Password => { + if password__.is_some() { + return Err(serde::de::Error::duplicate_field("password")); + } + password__ = Some(map_.next_value()?); } } } - Ok(WorkloadMountStatus { - mounts: mounts__.unwrap_or_default(), + Ok(OciRegistryUsernamePassword { + username: username__.unwrap_or_default(), + password: password__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadMountStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.OciRegistryUsernamePassword", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadPciDeviceInfo { +impl serde::Serialize for ProcessNamespace { #[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() + let variant = match self { + Self::Mount => "PROCESS_NAMESPACE_MOUNT", + Self::Uts => "PROCESS_NAMESPACE_UTS", + Self::Ipc => "PROCESS_NAMESPACE_IPC", + Self::User => "PROCESS_NAMESPACE_USER", + Self::Pid => "PROCESS_NAMESPACE_PID", + Self::Net => "PROCESS_NAMESPACE_NET", + Self::Cgroup => "PROCESS_NAMESPACE_CGROUP", + Self::Time => "PROCESS_NAMESPACE_TIME", + }; + serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceInfo { +impl<'de> serde::Deserialize<'de> for ProcessNamespace { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "location", + "PROCESS_NAMESPACE_MOUNT", + "PROCESS_NAMESPACE_UTS", + "PROCESS_NAMESPACE_IPC", + "PROCESS_NAMESPACE_USER", + "PROCESS_NAMESPACE_PID", + "PROCESS_NAMESPACE_NET", + "PROCESS_NAMESPACE_CGROUP", + "PROCESS_NAMESPACE_TIME", ]; - #[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; + type Value = ProcessNamespace; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadPciDeviceInfo") + write!(formatter, "expected one of: {:?}", &FIELDS) } - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, { - 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(), - }) + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) } - } - deserializer.deserialize_struct("protect.control.v1.WorkloadPciDeviceInfo", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for WorkloadPciDeviceSpec { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "PROCESS_NAMESPACE_MOUNT" => Ok(ProcessNamespace::Mount), + "PROCESS_NAMESPACE_UTS" => Ok(ProcessNamespace::Uts), + "PROCESS_NAMESPACE_IPC" => Ok(ProcessNamespace::Ipc), + "PROCESS_NAMESPACE_USER" => Ok(ProcessNamespace::User), + "PROCESS_NAMESPACE_PID" => Ok(ProcessNamespace::Pid), + "PROCESS_NAMESPACE_NET" => Ok(ProcessNamespace::Net), + "PROCESS_NAMESPACE_CGROUP" => Ok(ProcessNamespace::Cgroup), + "PROCESS_NAMESPACE_TIME" => Ok(ProcessNamespace::Time), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ProcessSpec { + #[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() { + if !self.environment.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)?; + if !self.command.is_empty() { + len += 1; + } + if !self.working_directory.is_empty() { + len += 1; + } + if self.tty { + len += 1; + } + if self.terminal_size.is_some() { + len += 1; + } + if self.user.is_some() { + len += 1; + } + if self.group.is_some() { + len += 1; + } + if self.stdin { + len += 1; + } + if self.stdout { + len += 1; + } + 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)?; + } + if !self.command.is_empty() { + struct_ser.serialize_field("command", &self.command)?; + } + if !self.working_directory.is_empty() { + struct_ser.serialize_field("workingDirectory", &self.working_directory)?; + } + if self.tty { + struct_ser.serialize_field("tty", &self.tty)?; + } + if let Some(v) = self.terminal_size.as_ref() { + struct_ser.serialize_field("terminalSize", v)?; + } + if let Some(v) = self.user.as_ref() { + struct_ser.serialize_field("user", v)?; + } + if let Some(v) = self.group.as_ref() { + struct_ser.serialize_field("group", v)?; + } + if self.stdin { + struct_ser.serialize_field("stdin", &self.stdin)?; + } + if self.stdout { + struct_ser.serialize_field("stdout", &self.stdout)?; + } + 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() } } -impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceSpec { +impl<'de> serde::Deserialize<'de> for ProcessSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "location", + "environment", + "command", + "working_directory", + "workingDirectory", + "tty", + "terminal_size", + "terminalSize", + "user", + "group", + "stdin", + "stdout", + "stderr", + "additional_gids", + "additionalGids", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Location, + Environment, + Command, + WorkingDirectory, + Tty, + TerminalSize, + User, + Group, + Stdin, + Stdout, + Stderr, + AdditionalGids, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -13098,7 +13828,17 @@ impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceSpec { E: serde::de::Error, { match value { - "location" => Ok(GeneratedField::Location), + "environment" => Ok(GeneratedField::Environment), + "command" => Ok(GeneratedField::Command), + "workingDirectory" | "working_directory" => Ok(GeneratedField::WorkingDirectory), + "tty" => Ok(GeneratedField::Tty), + "terminalSize" | "terminal_size" => Ok(GeneratedField::TerminalSize), + "user" => Ok(GeneratedField::User), + "group" => Ok(GeneratedField::Group), + "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)), } } @@ -13108,36 +13848,119 @@ impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadPciDeviceSpec; + type Value = ProcessSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadPciDeviceSpec") + formatter.write_str("struct protect.control.v1.ProcessSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut location__ = None; + let mut environment__ = None; + let mut command__ = None; + let mut working_directory__ = None; + let mut tty__ = None; + let mut terminal_size__ = None; + let mut user__ = None; + let mut group__ = None; + 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::Location => { - if location__.is_some() { - return Err(serde::de::Error::duplicate_field("location")); + GeneratedField::Environment => { + if environment__.is_some() { + return Err(serde::de::Error::duplicate_field("environment")); } - location__ = Some(map_.next_value()?); + environment__ = Some(map_.next_value()?); + } + GeneratedField::Command => { + if command__.is_some() { + return Err(serde::de::Error::duplicate_field("command")); + } + command__ = Some(map_.next_value()?); + } + GeneratedField::WorkingDirectory => { + if working_directory__.is_some() { + return Err(serde::de::Error::duplicate_field("workingDirectory")); + } + working_directory__ = Some(map_.next_value()?); + } + GeneratedField::Tty => { + if tty__.is_some() { + return Err(serde::de::Error::duplicate_field("tty")); + } + tty__ = Some(map_.next_value()?); + } + GeneratedField::TerminalSize => { + if terminal_size__.is_some() { + return Err(serde::de::Error::duplicate_field("terminalSize")); + } + terminal_size__ = map_.next_value()?; + } + GeneratedField::User => { + if user__.is_some() { + return Err(serde::de::Error::duplicate_field("user")); + } + user__ = map_.next_value()?; + } + GeneratedField::Group => { + if group__.is_some() { + return Err(serde::de::Error::duplicate_field("group")); + } + group__ = map_.next_value()?; + } + GeneratedField::Stdin => { + if stdin__.is_some() { + return Err(serde::de::Error::duplicate_field("stdin")); + } + stdin__ = Some(map_.next_value()?); + } + GeneratedField::Stdout => { + if stdout__.is_some() { + return Err(serde::de::Error::duplicate_field("stdout")); + } + stdout__ = Some(map_.next_value()?); + } + GeneratedField::Stderr => { + if stderr__.is_some() { + return Err(serde::de::Error::duplicate_field("stderr")); + } + 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(WorkloadPciDeviceSpec { - location: location__.unwrap_or_default(), + Ok(ProcessSpec { + environment: environment__.unwrap_or_default(), + command: command__.unwrap_or_default(), + working_directory: working_directory__.unwrap_or_default(), + tty: tty__.unwrap_or_default(), + terminal_size: terminal_size__, + user: user__, + group: group__, + stdin: stdin__.unwrap_or_default(), + stdout: stdout__.unwrap_or_default(), + stderr: stderr__.unwrap_or_default(), + additional_gids: additional_gids__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadPciDeviceSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ProcessSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadPciDeviceStatus { +impl serde::Serialize for PruneImagesReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -13145,29 +13968,29 @@ impl serde::Serialize for WorkloadPciDeviceStatus { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.devices.is_empty() { + if !self.removed.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)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.PruneImagesReply", len)?; + if !self.removed.is_empty() { + struct_ser.serialize_field("removed", &self.removed)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceStatus { +impl<'de> serde::Deserialize<'de> for PruneImagesReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "devices", + "removed", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Devices, + Removed, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -13189,7 +14012,7 @@ impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceStatus { E: serde::de::Error, { match value { - "devices" => Ok(GeneratedField::Devices), + "removed" => Ok(GeneratedField::Removed), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -13199,66 +14022,58 @@ impl<'de> serde::Deserialize<'de> for WorkloadPciDeviceStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadPciDeviceStatus; + type Value = PruneImagesReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadPciDeviceStatus") + formatter.write_str("struct protect.control.v1.PruneImagesReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut devices__ = None; + let mut removed__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Devices => { - if devices__.is_some() { - return Err(serde::de::Error::duplicate_field("devices")); + GeneratedField::Removed => { + if removed__.is_some() { + return Err(serde::de::Error::duplicate_field("removed")); } - devices__ = Some(map_.next_value()?); + removed__ = Some(map_.next_value()?); } } } - Ok(WorkloadPciDeviceStatus { - devices: devices__.unwrap_or_default(), + Ok(PruneImagesReply { + removed: removed__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadPciDeviceStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.PruneImagesReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadScratchMount { +impl serde::Serialize for PruneImagesRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.path.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadScratchMount", len)?; - if !self.path.is_empty() { - struct_ser.serialize_field("path", &self.path)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.PruneImagesRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadScratchMount { +impl<'de> serde::Deserialize<'de> for PruneImagesRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "path", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Path, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -13279,10 +14094,7 @@ impl<'de> serde::Deserialize<'de> for WorkloadScratchMount { where E: serde::de::Error, { - match value { - "path" => Ok(GeneratedField::Path), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -13290,36 +14102,27 @@ impl<'de> serde::Deserialize<'de> for WorkloadScratchMount { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadScratchMount; + type Value = PruneImagesRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadScratchMount") + formatter.write_str("struct protect.control.v1.PruneImagesRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut path__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Path => { - if path__.is_some() { - return Err(serde::de::Error::duplicate_field("path")); - } - path__ = Some(map_.next_value()?); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(WorkloadScratchMount { - path: path__.unwrap_or_default(), + Ok(PruneImagesRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadScratchMount", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.PruneImagesRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadSecuritySpec { +impl serde::Serialize for PullImageReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -13327,105 +14130,45 @@ impl serde::Serialize for WorkloadSecuritySpec { { use serde::ser::SerializeStruct; let mut len = 0; - if self.strict_user_namespace { - len += 1; - } - if !self.raise_capabilities.is_empty() { - len += 1; - } - if !self.raise_ambient_capabilities.is_empty() { - len += 1; - } - if !self.drop_capabilities.is_empty() { - len += 1; - } - if self.privileged { - len += 1; - } - if self.disable_all_namespaces { - len += 1; - } - if !self.disable_namespaces.is_empty() { + if self.progress.is_some() { len += 1; } - if self.read_only_rootfs { + if self.spec.is_some() { len += 1; } - if self.no_new_privs { + if self.metadata.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadSecuritySpec", len)?; - if self.strict_user_namespace { - struct_ser.serialize_field("strictUserNamespace", &self.strict_user_namespace)?; - } - if !self.raise_capabilities.is_empty() { - struct_ser.serialize_field("raiseCapabilities", &self.raise_capabilities)?; - } - if !self.raise_ambient_capabilities.is_empty() { - struct_ser.serialize_field("raiseAmbientCapabilities", &self.raise_ambient_capabilities)?; - } - if !self.drop_capabilities.is_empty() { - struct_ser.serialize_field("dropCapabilities", &self.drop_capabilities)?; - } - if self.privileged { - struct_ser.serialize_field("privileged", &self.privileged)?; - } - if self.disable_all_namespaces { - struct_ser.serialize_field("disableAllNamespaces", &self.disable_all_namespaces)?; - } - if !self.disable_namespaces.is_empty() { - let v = self.disable_namespaces.iter().cloned().map(|v| { - ProcessNamespace::try_from(v) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v))) - }).collect::, _>>()?; - struct_ser.serialize_field("disableNamespaces", &v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.PullImageReply", len)?; + if let Some(v) = self.progress.as_ref() { + struct_ser.serialize_field("progress", v)?; } - if self.read_only_rootfs { - struct_ser.serialize_field("readOnlyRootfs", &self.read_only_rootfs)?; + if let Some(v) = self.spec.as_ref() { + struct_ser.serialize_field("spec", v)?; } - if self.no_new_privs { - struct_ser.serialize_field("noNewPrivs", &self.no_new_privs)?; + if let Some(v) = self.metadata.as_ref() { + struct_ser.serialize_field("metadata", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadSecuritySpec { +impl<'de> serde::Deserialize<'de> for PullImageReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "strict_user_namespace", - "strictUserNamespace", - "raise_capabilities", - "raiseCapabilities", - "raise_ambient_capabilities", - "raiseAmbientCapabilities", - "drop_capabilities", - "dropCapabilities", - "privileged", - "disable_all_namespaces", - "disableAllNamespaces", - "disable_namespaces", - "disableNamespaces", - "read_only_rootfs", - "readOnlyRootfs", - "no_new_privs", - "noNewPrivs", + "progress", + "spec", + "metadata", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - StrictUserNamespace, - RaiseCapabilities, - RaiseAmbientCapabilities, - DropCapabilities, - Privileged, - DisableAllNamespaces, - DisableNamespaces, - ReadOnlyRootfs, - NoNewPrivs, + Progress, + Spec, + Metadata, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -13447,15 +14190,9 @@ impl<'de> serde::Deserialize<'de> for WorkloadSecuritySpec { E: serde::de::Error, { match value { - "strictUserNamespace" | "strict_user_namespace" => Ok(GeneratedField::StrictUserNamespace), - "raiseCapabilities" | "raise_capabilities" => Ok(GeneratedField::RaiseCapabilities), - "raiseAmbientCapabilities" | "raise_ambient_capabilities" => Ok(GeneratedField::RaiseAmbientCapabilities), - "dropCapabilities" | "drop_capabilities" => Ok(GeneratedField::DropCapabilities), - "privileged" => Ok(GeneratedField::Privileged), - "disableAllNamespaces" | "disable_all_namespaces" => Ok(GeneratedField::DisableAllNamespaces), - "disableNamespaces" | "disable_namespaces" => Ok(GeneratedField::DisableNamespaces), - "readOnlyRootfs" | "read_only_rootfs" => Ok(GeneratedField::ReadOnlyRootfs), - "noNewPrivs" | "no_new_privs" => Ok(GeneratedField::NoNewPrivs), + "progress" => Ok(GeneratedField::Progress), + "spec" => Ok(GeneratedField::Spec), + "metadata" => Ok(GeneratedField::Metadata), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -13465,100 +14202,52 @@ impl<'de> serde::Deserialize<'de> for WorkloadSecuritySpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadSecuritySpec; + type Value = PullImageReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadSecuritySpec") + formatter.write_str("struct protect.control.v1.PullImageReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut strict_user_namespace__ = None; - let mut raise_capabilities__ = None; - let mut raise_ambient_capabilities__ = None; - let mut drop_capabilities__ = None; - let mut privileged__ = None; - let mut disable_all_namespaces__ = None; - let mut disable_namespaces__ = None; - let mut read_only_rootfs__ = None; - let mut no_new_privs__ = None; + let mut progress__ = None; + let mut spec__ = None; + let mut metadata__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::StrictUserNamespace => { - if strict_user_namespace__.is_some() { - return Err(serde::de::Error::duplicate_field("strictUserNamespace")); - } - strict_user_namespace__ = Some(map_.next_value()?); - } - GeneratedField::RaiseCapabilities => { - if raise_capabilities__.is_some() { - return Err(serde::de::Error::duplicate_field("raiseCapabilities")); - } - raise_capabilities__ = Some(map_.next_value()?); - } - GeneratedField::RaiseAmbientCapabilities => { - if raise_ambient_capabilities__.is_some() { - return Err(serde::de::Error::duplicate_field("raiseAmbientCapabilities")); - } - raise_ambient_capabilities__ = Some(map_.next_value()?); - } - GeneratedField::DropCapabilities => { - if drop_capabilities__.is_some() { - return Err(serde::de::Error::duplicate_field("dropCapabilities")); - } - drop_capabilities__ = Some(map_.next_value()?); - } - GeneratedField::Privileged => { - if privileged__.is_some() { - return Err(serde::de::Error::duplicate_field("privileged")); - } - privileged__ = Some(map_.next_value()?); - } - GeneratedField::DisableAllNamespaces => { - if disable_all_namespaces__.is_some() { - return Err(serde::de::Error::duplicate_field("disableAllNamespaces")); - } - disable_all_namespaces__ = Some(map_.next_value()?); - } - GeneratedField::DisableNamespaces => { - if disable_namespaces__.is_some() { - return Err(serde::de::Error::duplicate_field("disableNamespaces")); + GeneratedField::Progress => { + if progress__.is_some() { + return Err(serde::de::Error::duplicate_field("progress")); } - disable_namespaces__ = Some(map_.next_value::>()?.into_iter().map(|x| x as i32).collect()); + progress__ = map_.next_value()?; } - GeneratedField::ReadOnlyRootfs => { - if read_only_rootfs__.is_some() { - return Err(serde::de::Error::duplicate_field("readOnlyRootfs")); + GeneratedField::Spec => { + if spec__.is_some() { + return Err(serde::de::Error::duplicate_field("spec")); } - read_only_rootfs__ = Some(map_.next_value()?); + spec__ = map_.next_value()?; } - GeneratedField::NoNewPrivs => { - if no_new_privs__.is_some() { - return Err(serde::de::Error::duplicate_field("noNewPrivs")); + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); } - no_new_privs__ = Some(map_.next_value()?); + metadata__ = map_.next_value()?; } } } - Ok(WorkloadSecuritySpec { - strict_user_namespace: strict_user_namespace__.unwrap_or_default(), - raise_capabilities: raise_capabilities__.unwrap_or_default(), - raise_ambient_capabilities: raise_ambient_capabilities__.unwrap_or_default(), - drop_capabilities: drop_capabilities__.unwrap_or_default(), - privileged: privileged__.unwrap_or_default(), - disable_all_namespaces: disable_all_namespaces__.unwrap_or_default(), - disable_namespaces: disable_namespaces__.unwrap_or_default(), - read_only_rootfs: read_only_rootfs__.unwrap_or_default(), - no_new_privs: no_new_privs__.unwrap_or_default(), + Ok(PullImageReply { + progress: progress__, + spec: spec__, + metadata: metadata__, }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadSecuritySpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.PullImageReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadSpec { +impl serde::Serialize for PullImageRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -13566,131 +14255,83 @@ impl serde::Serialize for WorkloadSpec { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if !self.zone_id.is_empty() { - len += 1; - } - if self.image.is_some() { - len += 1; - } - if self.process.is_some() { - len += 1; - } - if !self.annotations.is_empty() { - len += 1; - } - if !self.mounts.is_empty() { - len += 1; - } - if self.security.is_some() { - len += 1; - } - if !self.scratch_mount.is_empty() { + if self.format != 0 { len += 1; } - if !self.cgroup_limits.is_empty() { + if self.overwrite_cache { len += 1; } - if !self.hostname.is_empty() { + if self.update { len += 1; } - if !self.block_devices.is_empty() { + if self.want_metadata { len += 1; } - if self.oom_score_adj.is_some() { + if self.auth.is_some() { len += 1; } - if !self.pci_devices.is_empty() { + if self.source.is_some() { 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)?; - } - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; - } - if let Some(v) = self.image.as_ref() { - struct_ser.serialize_field("image", v)?; - } - if let Some(v) = self.process.as_ref() { - struct_ser.serialize_field("process", v)?; - } - if !self.annotations.is_empty() { - struct_ser.serialize_field("annotations", &self.annotations)?; - } - if !self.mounts.is_empty() { - struct_ser.serialize_field("mounts", &self.mounts)?; - } - if let Some(v) = self.security.as_ref() { - struct_ser.serialize_field("security", v)?; - } - if !self.scratch_mount.is_empty() { - struct_ser.serialize_field("scratchMount", &self.scratch_mount)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.PullImageRequest", len)?; + if self.format != 0 { + let v = OciImageFormat::try_from(self.format) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; + struct_ser.serialize_field("format", &v)?; } - if !self.cgroup_limits.is_empty() { - struct_ser.serialize_field("cgroupLimits", &self.cgroup_limits)?; + if self.overwrite_cache { + struct_ser.serialize_field("overwriteCache", &self.overwrite_cache)?; } - if !self.hostname.is_empty() { - struct_ser.serialize_field("hostname", &self.hostname)?; + if self.update { + struct_ser.serialize_field("update", &self.update)?; } - if !self.block_devices.is_empty() { - struct_ser.serialize_field("blockDevices", &self.block_devices)?; + if self.want_metadata { + struct_ser.serialize_field("wantMetadata", &self.want_metadata)?; } - if let Some(v) = self.oom_score_adj.as_ref() { - struct_ser.serialize_field("oomScoreAdj", v)?; + if let Some(v) = self.auth.as_ref() { + struct_ser.serialize_field("auth", v)?; } - if !self.pci_devices.is_empty() { - struct_ser.serialize_field("pciDevices", &self.pci_devices)?; + if let Some(v) = self.source.as_ref() { + match v { + pull_image_request::Source::Image(v) => { + struct_ser.serialize_field("image", v)?; + } + pull_image_request::Source::KernelVariant(v) => { + struct_ser.serialize_field("kernelVariant", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadSpec { +impl<'de> serde::Deserialize<'de> for PullImageRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", - "zone_id", - "zoneId", + "format", + "overwrite_cache", + "overwriteCache", + "update", + "want_metadata", + "wantMetadata", + "auth", "image", - "process", - "annotations", - "mounts", - "security", - "scratch_mount", - "scratchMount", - "cgroup_limits", - "cgroupLimits", - "hostname", - "block_devices", - "blockDevices", - "oom_score_adj", - "oomScoreAdj", - "pci_devices", - "pciDevices", + "kernel_variant", + "kernelVariant", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, - ZoneId, + Format, + OverwriteCache, + Update, + WantMetadata, + Auth, Image, - Process, - Annotations, - Mounts, - Security, - ScratchMount, - CgroupLimits, - Hostname, - BlockDevices, - OomScoreAdj, - PciDevices, + KernelVariant, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -13712,19 +14353,13 @@ impl<'de> serde::Deserialize<'de> for WorkloadSpec { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "format" => Ok(GeneratedField::Format), + "overwriteCache" | "overwrite_cache" => Ok(GeneratedField::OverwriteCache), + "update" => Ok(GeneratedField::Update), + "wantMetadata" | "want_metadata" => Ok(GeneratedField::WantMetadata), + "auth" => Ok(GeneratedField::Auth), "image" => Ok(GeneratedField::Image), - "process" => Ok(GeneratedField::Process), - "annotations" => Ok(GeneratedField::Annotations), - "mounts" => Ok(GeneratedField::Mounts), - "security" => Ok(GeneratedField::Security), - "scratchMount" | "scratch_mount" => Ok(GeneratedField::ScratchMount), - "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), + "kernelVariant" | "kernel_variant" => Ok(GeneratedField::KernelVariant), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -13734,312 +14369,195 @@ impl<'de> serde::Deserialize<'de> for WorkloadSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadSpec; + type Value = PullImageRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadSpec") + formatter.write_str("struct protect.control.v1.PullImageRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; - let mut zone_id__ = None; - let mut image__ = None; - let mut process__ = None; - let mut annotations__ = None; - let mut mounts__ = None; - let mut security__ = None; - let mut scratch_mount__ = None; - 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; + let mut format__ = None; + let mut overwrite_cache__ = None; + let mut update__ = None; + let mut want_metadata__ = None; + let mut auth__ = None; + let mut source__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map_.next_value()?); - } - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); - } - zone_id__ = Some(map_.next_value()?); - } - GeneratedField::Image => { - if image__.is_some() { - return Err(serde::de::Error::duplicate_field("image")); - } - image__ = map_.next_value()?; - } - GeneratedField::Process => { - if process__.is_some() { - return Err(serde::de::Error::duplicate_field("process")); - } - process__ = map_.next_value()?; - } - GeneratedField::Annotations => { - if annotations__.is_some() { - return Err(serde::de::Error::duplicate_field("annotations")); + GeneratedField::Format => { + if format__.is_some() { + return Err(serde::de::Error::duplicate_field("format")); } - annotations__ = Some(map_.next_value()?); + format__ = Some(map_.next_value::()? as i32); } - GeneratedField::Mounts => { - if mounts__.is_some() { - return Err(serde::de::Error::duplicate_field("mounts")); + GeneratedField::OverwriteCache => { + if overwrite_cache__.is_some() { + return Err(serde::de::Error::duplicate_field("overwriteCache")); } - mounts__ = Some(map_.next_value()?); + overwrite_cache__ = Some(map_.next_value()?); } - GeneratedField::Security => { - if security__.is_some() { - return Err(serde::de::Error::duplicate_field("security")); + GeneratedField::Update => { + if update__.is_some() { + return Err(serde::de::Error::duplicate_field("update")); } - security__ = map_.next_value()?; + update__ = Some(map_.next_value()?); } - GeneratedField::ScratchMount => { - if scratch_mount__.is_some() { - return Err(serde::de::Error::duplicate_field("scratchMount")); + GeneratedField::WantMetadata => { + if want_metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("wantMetadata")); } - scratch_mount__ = Some(map_.next_value()?); + want_metadata__ = Some(map_.next_value()?); } - GeneratedField::CgroupLimits => { - if cgroup_limits__.is_some() { - return Err(serde::de::Error::duplicate_field("cgroupLimits")); + GeneratedField::Auth => { + if auth__.is_some() { + return Err(serde::de::Error::duplicate_field("auth")); } - cgroup_limits__ = Some(map_.next_value()?); + auth__ = map_.next_value()?; } - GeneratedField::Hostname => { - if hostname__.is_some() { - return Err(serde::de::Error::duplicate_field("hostname")); + GeneratedField::Image => { + if source__.is_some() { + return Err(serde::de::Error::duplicate_field("image")); } - hostname__ = Some(map_.next_value()?); + source__ = map_.next_value::<::std::option::Option<_>>()?.map(pull_image_request::Source::Image); } - GeneratedField::BlockDevices => { - if block_devices__.is_some() { - return Err(serde::de::Error::duplicate_field("blockDevices")); + GeneratedField::KernelVariant => { + if source__.is_some() { + return Err(serde::de::Error::duplicate_field("kernelVariant")); } - 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()?); + source__ = map_.next_value::<::std::option::Option<_>>()?.map(pull_image_request::Source::KernelVariant); } } } - Ok(WorkloadSpec { - name: name__.unwrap_or_default(), - zone_id: zone_id__.unwrap_or_default(), - image: image__, - process: process__, - annotations: annotations__.unwrap_or_default(), - mounts: mounts__.unwrap_or_default(), - security: security__, - scratch_mount: scratch_mount__.unwrap_or_default(), - 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(), + Ok(PullImageRequest { + format: format__.unwrap_or_default(), + overwrite_cache: overwrite_cache__.unwrap_or_default(), + update: update__.unwrap_or_default(), + want_metadata: want_metadata__.unwrap_or_default(), + auth: auth__, + source: source__, }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.PullImageRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadState { +impl serde::Serialize for ReadHypervisorConsoleReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Unknown => "WORKLOAD_STATE_UNKNOWN", - Self::Creating => "WORKLOAD_STATE_CREATING", - Self::Created => "WORKLOAD_STATE_CREATED", - Self::Running => "WORKLOAD_STATE_RUNNING", - Self::Completed => "WORKLOAD_STATE_COMPLETED", - Self::Destroying => "WORKLOAD_STATE_DESTROYING", - Self::Destroyed => "WORKLOAD_STATE_DESTROYED", - Self::Failed => "WORKLOAD_STATE_FAILED", - Self::Oomkilled => "WORKLOAD_STATE_OOMKILLED", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.data.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ReadHypervisorConsoleReply", len)?; + if !self.data.is_empty() { + struct_ser.serialize_field("data", &self.data)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadState { +impl<'de> serde::Deserialize<'de> for ReadHypervisorConsoleReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "WORKLOAD_STATE_UNKNOWN", - "WORKLOAD_STATE_CREATING", - "WORKLOAD_STATE_CREATED", - "WORKLOAD_STATE_RUNNING", - "WORKLOAD_STATE_COMPLETED", - "WORKLOAD_STATE_DESTROYING", - "WORKLOAD_STATE_DESTROYED", - "WORKLOAD_STATE_FAILED", - "WORKLOAD_STATE_OOMKILLED", + "data", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Data, + } + 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 = WorkloadState; + 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) - } + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "data" => Ok(GeneratedField::Data), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ReadHypervisorConsoleReply; - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ReadHypervisorConsoleReply") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "WORKLOAD_STATE_UNKNOWN" => Ok(WorkloadState::Unknown), - "WORKLOAD_STATE_CREATING" => Ok(WorkloadState::Creating), - "WORKLOAD_STATE_CREATED" => Ok(WorkloadState::Created), - "WORKLOAD_STATE_RUNNING" => Ok(WorkloadState::Running), - "WORKLOAD_STATE_COMPLETED" => Ok(WorkloadState::Completed), - "WORKLOAD_STATE_DESTROYING" => Ok(WorkloadState::Destroying), - "WORKLOAD_STATE_DESTROYED" => Ok(WorkloadState::Destroyed), - "WORKLOAD_STATE_FAILED" => Ok(WorkloadState::Failed), - "WORKLOAD_STATE_OOMKILLED" => Ok(WorkloadState::Oomkilled), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut data__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Data => { + if data__.is_some() { + return Err(serde::de::Error::duplicate_field("data")); + } + data__ = Some(map_.next_value()?); + } + } } + Ok(ReadHypervisorConsoleReply { + data: data__.unwrap_or_default(), + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ReadHypervisorConsoleReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for WorkloadStatus { +impl serde::Serialize for ReadHypervisorConsoleRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if self.state != 0 { - len += 1; - } - if self.exit_status.is_some() { - len += 1; - } - if self.error_status.is_some() { - len += 1; - } - if self.block_device_status.is_some() { - len += 1; - } - if self.mount_status.is_some() { - len += 1; - } - 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) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?; - struct_ser.serialize_field("state", &v)?; - } - if let Some(v) = self.exit_status.as_ref() { - struct_ser.serialize_field("exitStatus", v)?; - } - if let Some(v) = self.error_status.as_ref() { - struct_ser.serialize_field("errorStatus", v)?; - } - if let Some(v) = self.block_device_status.as_ref() { - struct_ser.serialize_field("blockDeviceStatus", v)?; - } - if let Some(v) = self.mount_status.as_ref() { - struct_ser.serialize_field("mountStatus", v)?; - } - 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)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ReadHypervisorConsoleRequest", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for WorkloadStatus { +impl<'de> serde::Deserialize<'de> for ReadHypervisorConsoleRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "state", - "exit_status", - "exitStatus", - "error_status", - "errorStatus", - "block_device_status", - "blockDeviceStatus", - "mount_status", - "mountStatus", - "created_at", - "createdAt", - "pci_device_status", - "pciDeviceStatus", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - State, - ExitStatus, - ErrorStatus, - BlockDeviceStatus, - MountStatus, - CreatedAt, - PciDeviceStatus, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -14060,16 +14578,7 @@ impl<'de> serde::Deserialize<'de> for WorkloadStatus { where E: serde::de::Error, { - match value { - "state" => Ok(GeneratedField::State), - "exitStatus" | "exit_status" => Ok(GeneratedField::ExitStatus), - "errorStatus" | "error_status" => Ok(GeneratedField::ErrorStatus), - "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)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -14077,84 +14586,27 @@ impl<'de> serde::Deserialize<'de> for WorkloadStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WorkloadStatus; + type Value = ReadHypervisorConsoleRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.WorkloadStatus") + formatter.write_str("struct protect.control.v1.ReadHypervisorConsoleRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut state__ = None; - let mut exit_status__ = None; - let mut error_status__ = None; - 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 => { - if state__.is_some() { - return Err(serde::de::Error::duplicate_field("state")); - } - state__ = Some(map_.next_value::()? as i32); - } - GeneratedField::ExitStatus => { - if exit_status__.is_some() { - return Err(serde::de::Error::duplicate_field("exitStatus")); - } - exit_status__ = map_.next_value()?; - } - GeneratedField::ErrorStatus => { - if error_status__.is_some() { - return Err(serde::de::Error::duplicate_field("errorStatus")); - } - error_status__ = map_.next_value()?; - } - GeneratedField::BlockDeviceStatus => { - if block_device_status__.is_some() { - return Err(serde::de::Error::duplicate_field("blockDeviceStatus")); - } - block_device_status__ = map_.next_value()?; - } - GeneratedField::MountStatus => { - if mount_status__.is_some() { - return Err(serde::de::Error::duplicate_field("mountStatus")); - } - mount_status__ = map_.next_value()?; - } - GeneratedField::CreatedAt => { - if created_at__.is_some() { - return Err(serde::de::Error::duplicate_field("createdAt")); - } - 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()?; - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(WorkloadStatus { - state: state__.unwrap_or_default(), - exit_status: exit_status__, - error_status: error_status__, - block_device_status: block_device_status__, - mount_status: mount_status__, - created_at: created_at__, - pci_device_status: pci_device_status__, + Ok(ReadHypervisorConsoleRequest { }) } } - deserializer.deserialize_struct("protect.control.v1.WorkloadStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ReadHypervisorConsoleRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Zone { +impl serde::Serialize for ReadZoneMetricsReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -14162,45 +14614,37 @@ impl serde::Serialize for Zone { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.id.is_empty() { - len += 1; - } - if self.spec.is_some() { + if self.root.is_some() { len += 1; } - if self.status.is_some() { + if self.processes.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.Zone", len)?; - if !self.id.is_empty() { - struct_ser.serialize_field("id", &self.id)?; - } - if let Some(v) = self.spec.as_ref() { - struct_ser.serialize_field("spec", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ReadZoneMetricsReply", len)?; + if let Some(v) = self.root.as_ref() { + struct_ser.serialize_field("root", v)?; } - if let Some(v) = self.status.as_ref() { - struct_ser.serialize_field("status", v)?; + if let Some(v) = self.processes.as_ref() { + struct_ser.serialize_field("processes", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Zone { +impl<'de> serde::Deserialize<'de> for ReadZoneMetricsReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "id", - "spec", - "status", + "root", + "processes", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Id, - Spec, - Status, + Root, + Processes, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -14222,9 +14666,8 @@ impl<'de> serde::Deserialize<'de> for Zone { E: serde::de::Error, { match value { - "id" => Ok(GeneratedField::Id), - "spec" => Ok(GeneratedField::Spec), - "status" => Ok(GeneratedField::Status), + "root" => Ok(GeneratedField::Root), + "processes" => Ok(GeneratedField::Processes), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -14234,52 +14677,44 @@ impl<'de> serde::Deserialize<'de> for Zone { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Zone; + type Value = ReadZoneMetricsReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.Zone") + formatter.write_str("struct protect.control.v1.ReadZoneMetricsReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut id__ = None; - let mut spec__ = None; - let mut status__ = None; + let mut root__ = None; + let mut processes__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Id => { - if id__.is_some() { - return Err(serde::de::Error::duplicate_field("id")); - } - id__ = Some(map_.next_value()?); - } - GeneratedField::Spec => { - if spec__.is_some() { - return Err(serde::de::Error::duplicate_field("spec")); + GeneratedField::Root => { + if root__.is_some() { + return Err(serde::de::Error::duplicate_field("root")); } - spec__ = map_.next_value()?; + root__ = map_.next_value()?; } - GeneratedField::Status => { - if status__.is_some() { - return Err(serde::de::Error::duplicate_field("status")); + GeneratedField::Processes => { + if processes__.is_some() { + return Err(serde::de::Error::duplicate_field("processes")); } - status__ = map_.next_value()?; + processes__ = map_.next_value()?; } } } - Ok(Zone { - id: id__.unwrap_or_default(), - spec: spec__, - status: status__, + Ok(ReadZoneMetricsReply { + root: root__, + processes: processes__, }) } } - deserializer.deserialize_struct("protect.control.v1.Zone", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ReadZoneMetricsReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneChangedEvent { +impl serde::Serialize for ReadZoneMetricsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -14287,29 +14722,30 @@ impl serde::Serialize for ZoneChangedEvent { { use serde::ser::SerializeStruct; let mut len = 0; - if self.zone.is_some() { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneChangedEvent", len)?; - if let Some(v) = self.zone.as_ref() { - struct_ser.serialize_field("zone", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ReadZoneMetricsRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneChangedEvent { +impl<'de> serde::Deserialize<'de> for ReadZoneMetricsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone", + "zone_id", + "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Zone, + ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -14331,7 +14767,7 @@ impl<'de> serde::Deserialize<'de> for ZoneChangedEvent { E: serde::de::Error, { match value { - "zone" => Ok(GeneratedField::Zone), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -14341,36 +14777,36 @@ impl<'de> serde::Deserialize<'de> for ZoneChangedEvent { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneChangedEvent; + type Value = ReadZoneMetricsRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneChangedEvent") + formatter.write_str("struct protect.control.v1.ReadZoneMetricsRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone__ = None; + let mut zone_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Zone => { - if zone__.is_some() { - return Err(serde::de::Error::duplicate_field("zone")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - zone__ = map_.next_value()?; + zone_id__ = Some(map_.next_value()?); } } } - Ok(ZoneChangedEvent { - zone: zone__, + Ok(ReadZoneMetricsRequest { + zone_id: zone_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneChangedEvent", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ReadZoneMetricsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneConsoleReply { +impl serde::Serialize for RemoveImageReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -14378,31 +14814,29 @@ impl serde::Serialize for ZoneConsoleReply { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.data.is_empty() { + if self.removed { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneConsoleReply", len)?; - if !self.data.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.RemoveImageReply", len)?; + if self.removed { + struct_ser.serialize_field("removed", &self.removed)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneConsoleReply { +impl<'de> serde::Deserialize<'de> for RemoveImageReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "data", + "removed", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Data, + Removed, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -14424,7 +14858,7 @@ impl<'de> serde::Deserialize<'de> for ZoneConsoleReply { E: serde::de::Error, { match value { - "data" => Ok(GeneratedField::Data), + "removed" => Ok(GeneratedField::Removed), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -14434,38 +14868,36 @@ impl<'de> serde::Deserialize<'de> for ZoneConsoleReply { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneConsoleReply; + type Value = RemoveImageReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneConsoleReply") + formatter.write_str("struct protect.control.v1.RemoveImageReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut data__ = None; + let mut removed__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Data => { - if data__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); + GeneratedField::Removed => { + if removed__.is_some() { + return Err(serde::de::Error::duplicate_field("removed")); } - data__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + removed__ = Some(map_.next_value()?); } } } - Ok(ZoneConsoleReply { - data: data__.unwrap_or_default(), + Ok(RemoveImageReply { + removed: removed__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneConsoleReply", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.RemoveImageReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneConsoleRequest { +impl serde::Serialize for RemoveImageRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -14473,49 +14905,39 @@ impl serde::Serialize for ZoneConsoleRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { - len += 1; - } - if !self.data.is_empty() { + if !self.digest.is_empty() { len += 1; } - if self.replay_history { + if self.format != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneConsoleRequest", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; - } - if !self.data.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.RemoveImageRequest", len)?; + if !self.digest.is_empty() { + struct_ser.serialize_field("digest", &self.digest)?; } - if self.replay_history { - struct_ser.serialize_field("replayHistory", &self.replay_history)?; + if self.format != 0 { + let v = OciImageFormat::try_from(self.format) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; + struct_ser.serialize_field("format", &v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneConsoleRequest { +impl<'de> serde::Deserialize<'de> for RemoveImageRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", - "data", - "replay_history", - "replayHistory", + "digest", + "format", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, - Data, - ReplayHistory, + Digest, + Format, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -14537,9 +14959,8 @@ impl<'de> serde::Deserialize<'de> for ZoneConsoleRequest { E: serde::de::Error, { match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - "data" => Ok(GeneratedField::Data), - "replayHistory" | "replay_history" => Ok(GeneratedField::ReplayHistory), + "digest" => Ok(GeneratedField::Digest), + "format" => Ok(GeneratedField::Format), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -14549,54 +14970,44 @@ impl<'de> serde::Deserialize<'de> for ZoneConsoleRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneConsoleRequest; + type Value = RemoveImageRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneConsoleRequest") + formatter.write_str("struct protect.control.v1.RemoveImageRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - let mut data__ = None; - let mut replay_history__ = None; + let mut digest__ = None; + let mut format__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); - } - zone_id__ = Some(map_.next_value()?); - } - GeneratedField::Data => { - if data__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); + GeneratedField::Digest => { + if digest__.is_some() { + return Err(serde::de::Error::duplicate_field("digest")); } - data__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + digest__ = Some(map_.next_value()?); } - GeneratedField::ReplayHistory => { - if replay_history__.is_some() { - return Err(serde::de::Error::duplicate_field("replayHistory")); + GeneratedField::Format => { + if format__.is_some() { + return Err(serde::de::Error::duplicate_field("format")); } - replay_history__ = Some(map_.next_value()?); + format__ = Some(map_.next_value::()? as i32); } } } - Ok(ZoneConsoleRequest { - zone_id: zone_id__.unwrap_or_default(), - data: data__.unwrap_or_default(), - replay_history: replay_history__.unwrap_or_default(), + Ok(RemoveImageRequest { + digest: digest__.unwrap_or_default(), + format: format__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneConsoleRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.RemoveImageRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneDeviceStatus { +impl serde::Serialize for ReplicateZoneReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -14604,37 +15015,48 @@ impl serde::Serialize for ZoneDeviceStatus { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.disks.is_empty() { + if self.mode != 0 { len += 1; } - if self.mount.is_some() { + if !self.export_path.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneDeviceStatus", len)?; - if !self.disks.is_empty() { - struct_ser.serialize_field("disks", &self.disks)?; + if !self.replicas.is_empty() { + len += 1; } - if let Some(v) = self.mount.as_ref() { - struct_ser.serialize_field("mount", v)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ReplicateZoneReply", len)?; + if self.mode != 0 { + let v = ZoneReplicateMode::try_from(self.mode) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?; + struct_ser.serialize_field("mode", &v)?; + } + if !self.export_path.is_empty() { + struct_ser.serialize_field("exportPath", &self.export_path)?; + } + if !self.replicas.is_empty() { + struct_ser.serialize_field("replicas", &self.replicas)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneDeviceStatus { +impl<'de> serde::Deserialize<'de> for ReplicateZoneReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "disks", - "mount", + "mode", + "export_path", + "exportPath", + "replicas", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Disks, - Mount, + Mode, + ExportPath, + Replicas, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -14656,8 +15078,9 @@ impl<'de> serde::Deserialize<'de> for ZoneDeviceStatus { E: serde::de::Error, { match value { - "disks" => Ok(GeneratedField::Disks), - "mount" => Ok(GeneratedField::Mount), + "mode" => Ok(GeneratedField::Mode), + "exportPath" | "export_path" => Ok(GeneratedField::ExportPath), + "replicas" => Ok(GeneratedField::Replicas), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -14667,44 +15090,52 @@ impl<'de> serde::Deserialize<'de> for ZoneDeviceStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneDeviceStatus; + type Value = ReplicateZoneReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneDeviceStatus") + formatter.write_str("struct protect.control.v1.ReplicateZoneReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut disks__ = None; - let mut mount__ = None; + let mut mode__ = None; + let mut export_path__ = None; + let mut replicas__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Disks => { - if disks__.is_some() { - return Err(serde::de::Error::duplicate_field("disks")); + GeneratedField::Mode => { + if mode__.is_some() { + return Err(serde::de::Error::duplicate_field("mode")); } - disks__ = Some(map_.next_value()?); + mode__ = Some(map_.next_value::()? as i32); } - GeneratedField::Mount => { - if mount__.is_some() { - return Err(serde::de::Error::duplicate_field("mount")); + GeneratedField::ExportPath => { + if export_path__.is_some() { + return Err(serde::de::Error::duplicate_field("exportPath")); } - mount__ = map_.next_value()?; + export_path__ = Some(map_.next_value()?); + } + GeneratedField::Replicas => { + if replicas__.is_some() { + return Err(serde::de::Error::duplicate_field("replicas")); + } + replicas__ = Some(map_.next_value()?); } } } - Ok(ZoneDeviceStatus { - disks: disks__.unwrap_or_default(), - mount: mount__, + Ok(ReplicateZoneReply { + mode: mode__.unwrap_or_default(), + export_path: export_path__.unwrap_or_default(), + replicas: replicas__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneDeviceStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ReplicateZoneReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneDiskStatus { +impl serde::Serialize for ReplicateZoneRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -14712,75 +15143,74 @@ impl serde::Serialize for ZoneDiskStatus { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_block_device.is_empty() { + if self.mode != 0 { len += 1; } - if !self.host_block_device.is_empty() { + if !self.zone_id.is_empty() { len += 1; } - if !self.host_image_file.is_empty() { + if !self.export_path.is_empty() { len += 1; } - if !self.filesystem_type.is_empty() { + if self.replicas != 0 { len += 1; } - if self.purpose != 0 { + if !self.names.is_empty() { len += 1; } - if self.delete { + if self.delete_export { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneDiskStatus", len)?; - if !self.zone_block_device.is_empty() { - struct_ser.serialize_field("zoneBlockDevice", &self.zone_block_device)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ReplicateZoneRequest", len)?; + if self.mode != 0 { + let v = ZoneReplicateMode::try_from(self.mode) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?; + struct_ser.serialize_field("mode", &v)?; } - if !self.host_block_device.is_empty() { - struct_ser.serialize_field("hostBlockDevice", &self.host_block_device)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } - if !self.host_image_file.is_empty() { - struct_ser.serialize_field("hostImageFile", &self.host_image_file)?; + if !self.export_path.is_empty() { + struct_ser.serialize_field("exportPath", &self.export_path)?; } - if !self.filesystem_type.is_empty() { - struct_ser.serialize_field("filesystemType", &self.filesystem_type)?; + if self.replicas != 0 { + struct_ser.serialize_field("replicas", &self.replicas)?; } - if self.purpose != 0 { - let v = ZoneDiskStatusDiskPurpose::try_from(self.purpose) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.purpose)))?; - struct_ser.serialize_field("purpose", &v)?; + if !self.names.is_empty() { + struct_ser.serialize_field("names", &self.names)?; } - if self.delete { - struct_ser.serialize_field("delete", &self.delete)?; + if self.delete_export { + struct_ser.serialize_field("deleteExport", &self.delete_export)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneDiskStatus { +impl<'de> serde::Deserialize<'de> for ReplicateZoneRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_block_device", - "zoneBlockDevice", - "host_block_device", - "hostBlockDevice", - "host_image_file", - "hostImageFile", - "filesystem_type", - "filesystemType", - "purpose", - "delete", + "mode", + "zone_id", + "zoneId", + "export_path", + "exportPath", + "replicas", + "names", + "delete_export", + "deleteExport", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneBlockDevice, - HostBlockDevice, - HostImageFile, - FilesystemType, - Purpose, - Delete, + Mode, + ZoneId, + ExportPath, + Replicas, + Names, + DeleteExport, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -14802,12 +15232,12 @@ impl<'de> serde::Deserialize<'de> for ZoneDiskStatus { E: serde::de::Error, { match value { - "zoneBlockDevice" | "zone_block_device" => Ok(GeneratedField::ZoneBlockDevice), - "hostBlockDevice" | "host_block_device" => Ok(GeneratedField::HostBlockDevice), - "hostImageFile" | "host_image_file" => Ok(GeneratedField::HostImageFile), - "filesystemType" | "filesystem_type" => Ok(GeneratedField::FilesystemType), - "purpose" => Ok(GeneratedField::Purpose), - "delete" => Ok(GeneratedField::Delete), + "mode" => Ok(GeneratedField::Mode), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "exportPath" | "export_path" => Ok(GeneratedField::ExportPath), + "replicas" => Ok(GeneratedField::Replicas), + "names" => Ok(GeneratedField::Names), + "deleteExport" | "delete_export" => Ok(GeneratedField::DeleteExport), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -14817,187 +15247,132 @@ impl<'de> serde::Deserialize<'de> for ZoneDiskStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneDiskStatus; + type Value = ReplicateZoneRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneDiskStatus") + formatter.write_str("struct protect.control.v1.ReplicateZoneRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_block_device__ = None; - let mut host_block_device__ = None; - let mut host_image_file__ = None; - let mut filesystem_type__ = None; - let mut purpose__ = None; - let mut delete__ = None; + let mut mode__ = None; + let mut zone_id__ = None; + let mut export_path__ = None; + let mut replicas__ = None; + let mut names__ = None; + let mut delete_export__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneBlockDevice => { - if zone_block_device__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneBlockDevice")); + GeneratedField::Mode => { + if mode__.is_some() { + return Err(serde::de::Error::duplicate_field("mode")); } - zone_block_device__ = Some(map_.next_value()?); + mode__ = Some(map_.next_value::()? as i32); } - GeneratedField::HostBlockDevice => { - if host_block_device__.is_some() { - return Err(serde::de::Error::duplicate_field("hostBlockDevice")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - host_block_device__ = Some(map_.next_value()?); + zone_id__ = Some(map_.next_value()?); } - GeneratedField::HostImageFile => { - if host_image_file__.is_some() { - return Err(serde::de::Error::duplicate_field("hostImageFile")); + GeneratedField::ExportPath => { + if export_path__.is_some() { + return Err(serde::de::Error::duplicate_field("exportPath")); } - host_image_file__ = Some(map_.next_value()?); + export_path__ = Some(map_.next_value()?); } - GeneratedField::FilesystemType => { - if filesystem_type__.is_some() { - return Err(serde::de::Error::duplicate_field("filesystemType")); + GeneratedField::Replicas => { + if replicas__.is_some() { + return Err(serde::de::Error::duplicate_field("replicas")); } - filesystem_type__ = Some(map_.next_value()?); + replicas__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Purpose => { - if purpose__.is_some() { - return Err(serde::de::Error::duplicate_field("purpose")); + GeneratedField::Names => { + if names__.is_some() { + return Err(serde::de::Error::duplicate_field("names")); } - purpose__ = Some(map_.next_value::()? as i32); + names__ = Some(map_.next_value()?); } - GeneratedField::Delete => { - if delete__.is_some() { - return Err(serde::de::Error::duplicate_field("delete")); + GeneratedField::DeleteExport => { + if delete_export__.is_some() { + return Err(serde::de::Error::duplicate_field("deleteExport")); } - delete__ = Some(map_.next_value()?); + delete_export__ = Some(map_.next_value()?); } } } - Ok(ZoneDiskStatus { - zone_block_device: zone_block_device__.unwrap_or_default(), - host_block_device: host_block_device__.unwrap_or_default(), - host_image_file: host_image_file__.unwrap_or_default(), - filesystem_type: filesystem_type__.unwrap_or_default(), - purpose: purpose__.unwrap_or_default(), - delete: delete__.unwrap_or_default(), + Ok(ReplicateZoneRequest { + mode: mode__.unwrap_or_default(), + zone_id: zone_id__.unwrap_or_default(), + export_path: export_path__.unwrap_or_default(), + replicas: replicas__.unwrap_or_default(), + names: names__.unwrap_or_default(), + delete_export: delete_export__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneDiskStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ReplicateZoneRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneDiskStatusDiskPurpose { +impl serde::Serialize for ReplicatedZone { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Unknown => "ZONE_DISK_STATUS_DISK_PURPOSE_UNKNOWN", - Self::Addons => "ZONE_DISK_STATUS_DISK_PURPOSE_ADDONS", - Self::Scratch => "ZONE_DISK_STATUS_DISK_PURPOSE_SCRATCH", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if !self.name.is_empty() { + len += 1; + } + if !self.error.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ReplicatedZone", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if !self.error.is_empty() { + struct_ser.serialize_field("error", &self.error)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneDiskStatusDiskPurpose { +impl<'de> serde::Deserialize<'de> for ReplicatedZone { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ZONE_DISK_STATUS_DISK_PURPOSE_UNKNOWN", - "ZONE_DISK_STATUS_DISK_PURPOSE_ADDONS", - "ZONE_DISK_STATUS_DISK_PURPOSE_SCRATCH", + "zone_id", + "zoneId", + "name", + "error", ]; - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneDiskStatusDiskPurpose; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + Name, + Error, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result where - E: serde::de::Error, + D: serde::Deserializer<'de>, { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "ZONE_DISK_STATUS_DISK_PURPOSE_UNKNOWN" => Ok(ZoneDiskStatusDiskPurpose::Unknown), - "ZONE_DISK_STATUS_DISK_PURPOSE_ADDONS" => Ok(ZoneDiskStatusDiskPurpose::Addons), - "ZONE_DISK_STATUS_DISK_PURPOSE_SCRATCH" => Ok(ZoneDiskStatusDiskPurpose::Scratch), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for ZoneErrorStatus { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.message.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneErrorStatus", len)?; - if !self.message.is_empty() { - struct_ser.serialize_field("message", &self.message)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ZoneErrorStatus { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "message", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Message, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; + struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { type Value = GeneratedField; @@ -15012,7 +15387,9 @@ impl<'de> serde::Deserialize<'de> for ZoneErrorStatus { E: serde::de::Error, { match value { - "message" => Ok(GeneratedField::Message), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "name" => Ok(GeneratedField::Name), + "error" => Ok(GeneratedField::Error), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -15022,36 +15399,52 @@ impl<'de> serde::Deserialize<'de> for ZoneErrorStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneErrorStatus; + type Value = ReplicatedZone; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneErrorStatus") + formatter.write_str("struct protect.control.v1.ReplicatedZone") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut message__ = None; + let mut zone_id__ = None; + let mut name__ = None; + let mut error__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Message => { - if message__.is_some() { - return Err(serde::de::Error::duplicate_field("message")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - message__ = Some(map_.next_value()?); + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::Error => { + if error__.is_some() { + return Err(serde::de::Error::duplicate_field("error")); + } + error__ = Some(map_.next_value()?); } } } - Ok(ZoneErrorStatus { - message: message__.unwrap_or_default(), + Ok(ReplicatedZone { + zone_id: zone_id__.unwrap_or_default(), + name: name__.unwrap_or_default(), + error: error__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneErrorStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ReplicatedZone", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneExitStatus { +impl serde::Serialize for ResolveWorkloadIdReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -15059,29 +15452,30 @@ impl serde::Serialize for ZoneExitStatus { { use serde::ser::SerializeStruct; let mut len = 0; - if self.code != 0 { + if !self.workload_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneExitStatus", len)?; - if self.code != 0 { - struct_ser.serialize_field("code", &self.code)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveWorkloadIdReply", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneExitStatus { +impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "code", + "workload_id", + "workloadId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Code, + WorkloadId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -15103,7 +15497,7 @@ impl<'de> serde::Deserialize<'de> for ZoneExitStatus { E: serde::de::Error, { match value { - "code" => Ok(GeneratedField::Code), + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -15113,38 +15507,36 @@ impl<'de> serde::Deserialize<'de> for ZoneExitStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneExitStatus; + type Value = ResolveWorkloadIdReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneExitStatus") + formatter.write_str("struct protect.control.v1.ResolveWorkloadIdReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut code__ = None; + let mut workload_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Code => { - if code__.is_some() { - return Err(serde::de::Error::duplicate_field("code")); + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); } - code__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + workload_id__ = Some(map_.next_value()?); } } } - Ok(ZoneExitStatus { - code: code__.unwrap_or_default(), + Ok(ResolveWorkloadIdReply { + workload_id: workload_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneExitStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolveWorkloadIdReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelEventParam { +impl serde::Serialize for ResolveWorkloadIdRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -15155,40 +15547,14 @@ impl serde::Serialize for ZoneKernelEventParam { if !self.name.is_empty() { len += 1; } - if self.param_type != 0 { - len += 1; - } - if !self.param_data.is_empty() { - len += 1; - } - if !self.param_pretty.is_empty() { - len += 1; - } - if !self.param_type_pretty.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelEventParam", len)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveWorkloadIdRequest", len)?; if !self.name.is_empty() { struct_ser.serialize_field("name", &self.name)?; } - if self.param_type != 0 { - struct_ser.serialize_field("paramType", &self.param_type)?; - } - if !self.param_data.is_empty() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("paramData", pbjson::private::base64::encode(&self.param_data).as_str())?; - } - if !self.param_pretty.is_empty() { - struct_ser.serialize_field("paramPretty", &self.param_pretty)?; - } - if !self.param_type_pretty.is_empty() { - struct_ser.serialize_field("paramTypePretty", &self.param_type_pretty)?; - } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelEventParam { +impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where @@ -15196,23 +15562,11 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelEventParam { { const FIELDS: &[&str] = &[ "name", - "param_type", - "paramType", - "param_data", - "paramData", - "param_pretty", - "paramPretty", - "param_type_pretty", - "paramTypePretty", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Name, - ParamType, - ParamData, - ParamPretty, - ParamTypePretty, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -15235,10 +15589,6 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelEventParam { { match value { "name" => Ok(GeneratedField::Name), - "paramType" | "param_type" => Ok(GeneratedField::ParamType), - "paramData" | "param_data" => Ok(GeneratedField::ParamData), - "paramPretty" | "param_pretty" => Ok(GeneratedField::ParamPretty), - "paramTypePretty" | "param_type_pretty" => Ok(GeneratedField::ParamTypePretty), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -15248,21 +15598,17 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelEventParam { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelEventParam; + type Value = ResolveWorkloadIdRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelEventParam") + formatter.write_str("struct protect.control.v1.ResolveWorkloadIdRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { let mut name__ = None; - let mut param_type__ = None; - let mut param_data__ = None; - let mut param_pretty__ = None; - let mut param_type_pretty__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Name => { @@ -15271,71 +15617,48 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelEventParam { } name__ = Some(map_.next_value()?); } - GeneratedField::ParamType => { - if param_type__.is_some() { - return Err(serde::de::Error::duplicate_field("paramType")); - } - param_type__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::ParamData => { - if param_data__.is_some() { - return Err(serde::de::Error::duplicate_field("paramData")); - } - param_data__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::ParamPretty => { - if param_pretty__.is_some() { - return Err(serde::de::Error::duplicate_field("paramPretty")); - } - param_pretty__ = Some(map_.next_value()?); - } - GeneratedField::ParamTypePretty => { - if param_type_pretty__.is_some() { - return Err(serde::de::Error::duplicate_field("paramTypePretty")); - } - param_type_pretty__ = Some(map_.next_value()?); - } } } - Ok(ZoneKernelEventParam { + Ok(ResolveWorkloadIdRequest { name: name__.unwrap_or_default(), - param_type: param_type__.unwrap_or_default(), - param_data: param_data__.unwrap_or_default(), - param_pretty: param_pretty__.unwrap_or_default(), - param_type_pretty: param_type_pretty__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelEventParam", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolveWorkloadIdRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelEventStreamStop { +impl serde::Serialize for ResolveWorkloadIdsReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelEventStreamStop", len)?; + let mut len = 0; + if !self.workload_ids.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveWorkloadIdsReply", len)?; + if !self.workload_ids.is_empty() { + struct_ser.serialize_field("workloadIds", &self.workload_ids)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelEventStreamStop { +impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdsReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "workload_ids", + "workloadIds", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + WorkloadIds, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -15356,7 +15679,10 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelEventStreamStop { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "workloadIds" | "workload_ids" => Ok(GeneratedField::WorkloadIds), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -15364,27 +15690,36 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelEventStreamStop { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelEventStreamStop; + type Value = ResolveWorkloadIdsReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelEventStreamStop") + formatter.write_str("struct protect.control.v1.ResolveWorkloadIdsReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut workload_ids__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::WorkloadIds => { + if workload_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadIds")); + } + workload_ids__ = Some(map_.next_value()?); + } + } } - Ok(ZoneKernelEventStreamStop { + Ok(ResolveWorkloadIdsReply { + workload_ids: workload_ids__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelEventStreamStop", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolveWorkloadIdsReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelEventStreamUpdate { +impl serde::Serialize for ResolveWorkloadIdsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -15392,30 +15727,29 @@ impl serde::Serialize for ZoneKernelEventStreamUpdate { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.enabled_syscalls.is_empty() { + if !self.name.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelEventStreamUpdate", len)?; - if !self.enabled_syscalls.is_empty() { - struct_ser.serialize_field("enabledSyscalls", &self.enabled_syscalls)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveWorkloadIdsRequest", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelEventStreamUpdate { +impl<'de> serde::Deserialize<'de> for ResolveWorkloadIdsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "enabled_syscalls", - "enabledSyscalls", + "name", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - EnabledSyscalls, + Name, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -15437,7 +15771,7 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelEventStreamUpdate { E: serde::de::Error, { match value { - "enabledSyscalls" | "enabled_syscalls" => Ok(GeneratedField::EnabledSyscalls), + "name" => Ok(GeneratedField::Name), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -15447,39 +15781,36 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelEventStreamUpdate { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelEventStreamUpdate; + type Value = ResolveWorkloadIdsRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelEventStreamUpdate") + formatter.write_str("struct protect.control.v1.ResolveWorkloadIdsRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut enabled_syscalls__ = None; + let mut name__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::EnabledSyscalls => { - if enabled_syscalls__.is_some() { - return Err(serde::de::Error::duplicate_field("enabledSyscalls")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - enabled_syscalls__ = - Some(map_.next_value::>>()? - .into_iter().map(|x| x.0).collect()) - ; + name__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelEventStreamUpdate { - enabled_syscalls: enabled_syscalls__.unwrap_or_default(), + Ok(ResolveWorkloadIdsRequest { + name: name__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelEventStreamUpdate", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolveWorkloadIdsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelFdInfo { +impl serde::Serialize for ResolveZoneIdReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -15487,78 +15818,30 @@ impl serde::Serialize for ZoneKernelFdInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if self.fd.is_some() { - len += 1; - } - if self.inode != 0 { - len += 1; - } - if self.fd_type != 0 { - len += 1; - } - if self.info.is_some() { - len += 1; - } - if self.open_flags != 0 { - len += 1; - } - if self.state_flags != 0 { + if !self.zone_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelFdInfo", len)?; - if let Some(v) = self.fd.as_ref() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("fd", ToString::to_string(&v).as_str())?; - } - if self.inode != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("inode", ToString::to_string(&self.inode).as_str())?; - } - if self.fd_type != 0 { - let v = ZoneKernelFdType::try_from(self.fd_type) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fd_type)))?; - struct_ser.serialize_field("fdType", &v)?; - } - if let Some(v) = self.info.as_ref() { - struct_ser.serialize_field("info", v)?; - } - if self.open_flags != 0 { - struct_ser.serialize_field("openFlags", &self.open_flags)?; - } - if self.state_flags != 0 { - struct_ser.serialize_field("stateFlags", &self.state_flags)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveZoneIdReply", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelFdInfo { +impl<'de> serde::Deserialize<'de> for ResolveZoneIdReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "fd", - "inode", - "fd_type", - "fdType", - "info", - "open_flags", - "openFlags", - "state_flags", - "stateFlags", + "zone_id", + "zoneId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Fd, - Inode, - FdType, - Info, - OpenFlags, - StateFlags, + ZoneId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -15580,12 +15863,7 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelFdInfo { E: serde::de::Error, { match value { - "fd" => Ok(GeneratedField::Fd), - "inode" => Ok(GeneratedField::Inode), - "fdType" | "fd_type" => Ok(GeneratedField::FdType), - "info" => Ok(GeneratedField::Info), - "openFlags" | "open_flags" => Ok(GeneratedField::OpenFlags), - "stateFlags" | "state_flags" => Ok(GeneratedField::StateFlags), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -15595,84 +15873,36 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelFdInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelFdInfo; + type Value = ResolveZoneIdReply; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelFdInfo") + formatter.write_str("struct protect.control.v1.ResolveZoneIdReply") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut fd__ = None; - let mut inode__ = None; - let mut fd_type__ = None; - let mut info__ = None; - let mut open_flags__ = None; - let mut state_flags__ = None; + let mut zone_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Fd => { - if fd__.is_some() { - return Err(serde::de::Error::duplicate_field("fd")); - } - fd__ = - map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) - ; - } - GeneratedField::Inode => { - if inode__.is_some() { - return Err(serde::de::Error::duplicate_field("inode")); - } - inode__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::FdType => { - if fd_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fdType")); - } - fd_type__ = Some(map_.next_value::()? as i32); - } - GeneratedField::Info => { - if info__.is_some() { - return Err(serde::de::Error::duplicate_field("info")); - } - info__ = map_.next_value()?; - } - GeneratedField::OpenFlags => { - if open_flags__.is_some() { - return Err(serde::de::Error::duplicate_field("openFlags")); - } - open_flags__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::StateFlags => { - if state_flags__.is_some() { - return Err(serde::de::Error::duplicate_field("stateFlags")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - state_flags__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + zone_id__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelFdInfo { - fd: fd__, - inode: inode__.unwrap_or_default(), - fd_type: fd_type__.unwrap_or_default(), - info: info__, - open_flags: open_flags__.unwrap_or_default(), - state_flags: state_flags__.unwrap_or_default(), + Ok(ResolveZoneIdReply { + zone_id: zone_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelFdInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolveZoneIdReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelFdInfoData { +impl serde::Serialize for ResolveZoneIdRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -15680,75 +15910,29 @@ impl serde::Serialize for ZoneKernelFdInfoData { { use serde::ser::SerializeStruct; let mut len = 0; - if self.info_type.is_some() { + if !self.name.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelFdInfoData", len)?; - if let Some(v) = self.info_type.as_ref() { - match v { - zone_kernel_fd_info_data::InfoType::Ipv4Socket(v) => { - struct_ser.serialize_field("ipv4Socket", v)?; - } - zone_kernel_fd_info_data::InfoType::Ipv6Socket(v) => { - struct_ser.serialize_field("ipv6Socket", v)?; - } - zone_kernel_fd_info_data::InfoType::Ipv4ServerSocket(v) => { - struct_ser.serialize_field("ipv4ServerSocket", v)?; - } - zone_kernel_fd_info_data::InfoType::Ipv6ServerSocket(v) => { - struct_ser.serialize_field("ipv6ServerSocket", v)?; - } - zone_kernel_fd_info_data::InfoType::UnixSocket(v) => { - struct_ser.serialize_field("unixSocket", v)?; - } - zone_kernel_fd_info_data::InfoType::RegularFile(v) => { - struct_ser.serialize_field("regularFile", v)?; - } - zone_kernel_fd_info_data::InfoType::FileName(v) => { - struct_ser.serialize_field("fileName", v)?; - } - zone_kernel_fd_info_data::InfoType::Pidfd(v) => { - struct_ser.serialize_field("pidfd", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveZoneIdRequest", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelFdInfoData { +impl<'de> serde::Deserialize<'de> for ResolveZoneIdRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ipv4_socket", - "ipv4Socket", - "ipv6_socket", - "ipv6Socket", - "ipv4_server_socket", - "ipv4ServerSocket", - "ipv6_server_socket", - "ipv6ServerSocket", - "unix_socket", - "unixSocket", - "regular_file", - "regularFile", - "file_name", - "fileName", - "pidfd", + "name", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Ipv4Socket, - Ipv6Socket, - Ipv4ServerSocket, - Ipv6ServerSocket, - UnixSocket, - RegularFile, - FileName, - Pidfd, + Name, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -15770,14 +15954,7 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelFdInfoData { E: serde::de::Error, { match value { - "ipv4Socket" | "ipv4_socket" => Ok(GeneratedField::Ipv4Socket), - "ipv6Socket" | "ipv6_socket" => Ok(GeneratedField::Ipv6Socket), - "ipv4ServerSocket" | "ipv4_server_socket" => Ok(GeneratedField::Ipv4ServerSocket), - "ipv6ServerSocket" | "ipv6_server_socket" => Ok(GeneratedField::Ipv6ServerSocket), - "unixSocket" | "unix_socket" => Ok(GeneratedField::UnixSocket), - "regularFile" | "regular_file" => Ok(GeneratedField::RegularFile), - "fileName" | "file_name" => Ok(GeneratedField::FileName), - "pidfd" => Ok(GeneratedField::Pidfd), + "name" => Ok(GeneratedField::Name), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -15787,299 +15964,219 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelFdInfoData { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelFdInfoData; + type Value = ResolveZoneIdRequest; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelFdInfoData") + formatter.write_str("struct protect.control.v1.ResolveZoneIdRequest") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut info_type__ = None; + let mut name__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Ipv4Socket => { - if info_type__.is_some() { - return Err(serde::de::Error::duplicate_field("ipv4Socket")); - } - info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Ipv4Socket) -; - } - GeneratedField::Ipv6Socket => { - if info_type__.is_some() { - return Err(serde::de::Error::duplicate_field("ipv6Socket")); - } - info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Ipv6Socket) -; - } - GeneratedField::Ipv4ServerSocket => { - if info_type__.is_some() { - return Err(serde::de::Error::duplicate_field("ipv4ServerSocket")); - } - info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Ipv4ServerSocket) -; - } - GeneratedField::Ipv6ServerSocket => { - if info_type__.is_some() { - return Err(serde::de::Error::duplicate_field("ipv6ServerSocket")); - } - info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Ipv6ServerSocket) -; - } - GeneratedField::UnixSocket => { - if info_type__.is_some() { - return Err(serde::de::Error::duplicate_field("unixSocket")); - } - info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::UnixSocket) -; - } - GeneratedField::RegularFile => { - if info_type__.is_some() { - return Err(serde::de::Error::duplicate_field("regularFile")); - } - info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::RegularFile) -; - } - GeneratedField::FileName => { - if info_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fileName")); - } - info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::FileName); - } - GeneratedField::Pidfd => { - if info_type__.is_some() { - return Err(serde::de::Error::duplicate_field("pidfd")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Pidfd) -; + name__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelFdInfoData { - info_type: info_type__, + Ok(ResolveZoneIdRequest { + name: name__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelFdInfoData", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolveZoneIdRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelFdType { +impl serde::Serialize for ResolveZoneIdsReply { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Unknown => "ZONE_KERNEL_FD_TYPE_UNKNOWN", - Self::File => "ZONE_KERNEL_FD_TYPE_FILE", - Self::Directory => "ZONE_KERNEL_FD_TYPE_DIRECTORY", - Self::Ipv4Sock => "ZONE_KERNEL_FD_TYPE_IPV4_SOCK", - Self::Ipv6Sock => "ZONE_KERNEL_FD_TYPE_IPV6_SOCK", - Self::Ipv4Servsock => "ZONE_KERNEL_FD_TYPE_IPV4_SERVSOCK", - Self::Ipv6Servsock => "ZONE_KERNEL_FD_TYPE_IPV6_SERVSOCK", - Self::Fifo => "ZONE_KERNEL_FD_TYPE_FIFO", - Self::UnixSock => "ZONE_KERNEL_FD_TYPE_UNIX_SOCK", - Self::Event => "ZONE_KERNEL_FD_TYPE_EVENT", - Self::Unsupported => "ZONE_KERNEL_FD_TYPE_UNSUPPORTED", - Self::Signalfd => "ZONE_KERNEL_FD_TYPE_SIGNALFD", - Self::Eventpoll => "ZONE_KERNEL_FD_TYPE_EVENTPOLL", - Self::Inotify => "ZONE_KERNEL_FD_TYPE_INOTIFY", - Self::Timerfd => "ZONE_KERNEL_FD_TYPE_TIMERFD", - Self::Netlink => "ZONE_KERNEL_FD_TYPE_NETLINK", - Self::FileV2 => "ZONE_KERNEL_FD_TYPE_FILE_V2", - Self::Bpf => "ZONE_KERNEL_FD_TYPE_BPF", - Self::Userfaultfd => "ZONE_KERNEL_FD_TYPE_USERFAULTFD", - Self::Iouring => "ZONE_KERNEL_FD_TYPE_IOURING", - Self::Memfd => "ZONE_KERNEL_FD_TYPE_MEMFD", - Self::Pidfd => "ZONE_KERNEL_FD_TYPE_PIDFD", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_ids.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveZoneIdsReply", len)?; + if !self.zone_ids.is_empty() { + struct_ser.serialize_field("zoneIds", &self.zone_ids)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelFdType { +impl<'de> serde::Deserialize<'de> for ResolveZoneIdsReply { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ZONE_KERNEL_FD_TYPE_UNKNOWN", - "ZONE_KERNEL_FD_TYPE_FILE", - "ZONE_KERNEL_FD_TYPE_DIRECTORY", - "ZONE_KERNEL_FD_TYPE_IPV4_SOCK", - "ZONE_KERNEL_FD_TYPE_IPV6_SOCK", - "ZONE_KERNEL_FD_TYPE_IPV4_SERVSOCK", - "ZONE_KERNEL_FD_TYPE_IPV6_SERVSOCK", - "ZONE_KERNEL_FD_TYPE_FIFO", - "ZONE_KERNEL_FD_TYPE_UNIX_SOCK", - "ZONE_KERNEL_FD_TYPE_EVENT", - "ZONE_KERNEL_FD_TYPE_UNSUPPORTED", - "ZONE_KERNEL_FD_TYPE_SIGNALFD", - "ZONE_KERNEL_FD_TYPE_EVENTPOLL", - "ZONE_KERNEL_FD_TYPE_INOTIFY", - "ZONE_KERNEL_FD_TYPE_TIMERFD", - "ZONE_KERNEL_FD_TYPE_NETLINK", - "ZONE_KERNEL_FD_TYPE_FILE_V2", - "ZONE_KERNEL_FD_TYPE_BPF", - "ZONE_KERNEL_FD_TYPE_USERFAULTFD", - "ZONE_KERNEL_FD_TYPE_IOURING", - "ZONE_KERNEL_FD_TYPE_MEMFD", - "ZONE_KERNEL_FD_TYPE_PIDFD", + "zone_ids", + "zoneIds", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneIds, + } + 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 = ZoneKernelFdType; + 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) - } + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "zoneIds" | "zone_ids" => Ok(GeneratedField::ZoneIds), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ResolveZoneIdsReply; - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ResolveZoneIdsReply") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "ZONE_KERNEL_FD_TYPE_UNKNOWN" => Ok(ZoneKernelFdType::Unknown), - "ZONE_KERNEL_FD_TYPE_FILE" => Ok(ZoneKernelFdType::File), - "ZONE_KERNEL_FD_TYPE_DIRECTORY" => Ok(ZoneKernelFdType::Directory), - "ZONE_KERNEL_FD_TYPE_IPV4_SOCK" => Ok(ZoneKernelFdType::Ipv4Sock), - "ZONE_KERNEL_FD_TYPE_IPV6_SOCK" => Ok(ZoneKernelFdType::Ipv6Sock), - "ZONE_KERNEL_FD_TYPE_IPV4_SERVSOCK" => Ok(ZoneKernelFdType::Ipv4Servsock), - "ZONE_KERNEL_FD_TYPE_IPV6_SERVSOCK" => Ok(ZoneKernelFdType::Ipv6Servsock), - "ZONE_KERNEL_FD_TYPE_FIFO" => Ok(ZoneKernelFdType::Fifo), - "ZONE_KERNEL_FD_TYPE_UNIX_SOCK" => Ok(ZoneKernelFdType::UnixSock), - "ZONE_KERNEL_FD_TYPE_EVENT" => Ok(ZoneKernelFdType::Event), - "ZONE_KERNEL_FD_TYPE_UNSUPPORTED" => Ok(ZoneKernelFdType::Unsupported), - "ZONE_KERNEL_FD_TYPE_SIGNALFD" => Ok(ZoneKernelFdType::Signalfd), - "ZONE_KERNEL_FD_TYPE_EVENTPOLL" => Ok(ZoneKernelFdType::Eventpoll), - "ZONE_KERNEL_FD_TYPE_INOTIFY" => Ok(ZoneKernelFdType::Inotify), - "ZONE_KERNEL_FD_TYPE_TIMERFD" => Ok(ZoneKernelFdType::Timerfd), - "ZONE_KERNEL_FD_TYPE_NETLINK" => Ok(ZoneKernelFdType::Netlink), - "ZONE_KERNEL_FD_TYPE_FILE_V2" => Ok(ZoneKernelFdType::FileV2), - "ZONE_KERNEL_FD_TYPE_BPF" => Ok(ZoneKernelFdType::Bpf), - "ZONE_KERNEL_FD_TYPE_USERFAULTFD" => Ok(ZoneKernelFdType::Userfaultfd), - "ZONE_KERNEL_FD_TYPE_IOURING" => Ok(ZoneKernelFdType::Iouring), - "ZONE_KERNEL_FD_TYPE_MEMFD" => Ok(ZoneKernelFdType::Memfd), - "ZONE_KERNEL_FD_TYPE_PIDFD" => Ok(ZoneKernelFdType::Pidfd), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut zone_ids__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneIds => { + if zone_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneIds")); + } + zone_ids__ = Some(map_.next_value()?); + } + } } + Ok(ResolveZoneIdsReply { + zone_ids: zone_ids__.unwrap_or_default(), + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolveZoneIdsReply", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelIpProtocol { +impl serde::Serialize for ResolveZoneIdsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Unknown => "ZONE_KERNEL_IP_PROTOCOL_UNKNOWN", - Self::Na => "ZONE_KERNEL_IP_PROTOCOL_NA", - Self::Tcp => "ZONE_KERNEL_IP_PROTOCOL_TCP", - Self::Udp => "ZONE_KERNEL_IP_PROTOCOL_UDP", - Self::Icmp => "ZONE_KERNEL_IP_PROTOCOL_ICMP", - Self::Raw => "ZONE_KERNEL_IP_PROTOCOL_RAW", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolveZoneIdsRequest", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelIpProtocol { +impl<'de> serde::Deserialize<'de> for ResolveZoneIdsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ZONE_KERNEL_IP_PROTOCOL_UNKNOWN", - "ZONE_KERNEL_IP_PROTOCOL_NA", - "ZONE_KERNEL_IP_PROTOCOL_TCP", - "ZONE_KERNEL_IP_PROTOCOL_UDP", - "ZONE_KERNEL_IP_PROTOCOL_ICMP", - "ZONE_KERNEL_IP_PROTOCOL_RAW", + "name", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + } + 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 = ZoneKernelIpProtocol; + 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) - } + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "name" => Ok(GeneratedField::Name), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ResolveZoneIdsRequest; - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ResolveZoneIdsRequest") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "ZONE_KERNEL_IP_PROTOCOL_UNKNOWN" => Ok(ZoneKernelIpProtocol::Unknown), - "ZONE_KERNEL_IP_PROTOCOL_NA" => Ok(ZoneKernelIpProtocol::Na), - "ZONE_KERNEL_IP_PROTOCOL_TCP" => Ok(ZoneKernelIpProtocol::Tcp), - "ZONE_KERNEL_IP_PROTOCOL_UDP" => Ok(ZoneKernelIpProtocol::Udp), - "ZONE_KERNEL_IP_PROTOCOL_ICMP" => Ok(ZoneKernelIpProtocol::Icmp), - "ZONE_KERNEL_IP_PROTOCOL_RAW" => Ok(ZoneKernelIpProtocol::Raw), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut name__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + } } + Ok(ResolveZoneIdsRequest { + name: name__.unwrap_or_default(), + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolveZoneIdsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelIpv4ServerSocketInfo { +impl serde::Serialize for ResolvedSeccompProfile { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -16087,49 +16184,55 @@ impl serde::Serialize for ZoneKernelIpv4ServerSocketInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.local_ip.is_empty() { + if !self.default_action.is_empty() { len += 1; } - if self.local_port != 0 { + if self.default_errno_ret.is_some() { len += 1; } - if self.protocol != 0 { + if !self.architectures.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelIpv4ServerSocketInfo", len)?; - if !self.local_ip.is_empty() { - struct_ser.serialize_field("localIp", &self.local_ip)?; + if !self.syscalls.is_empty() { + len += 1; } - if self.local_port != 0 { - struct_ser.serialize_field("localPort", &self.local_port)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolvedSeccompProfile", len)?; + if !self.default_action.is_empty() { + struct_ser.serialize_field("defaultAction", &self.default_action)?; } - if self.protocol != 0 { - let v = ZoneKernelIpProtocol::try_from(self.protocol) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.protocol)))?; - struct_ser.serialize_field("protocol", &v)?; + if let Some(v) = self.default_errno_ret.as_ref() { + struct_ser.serialize_field("defaultErrnoRet", v)?; + } + if !self.architectures.is_empty() { + struct_ser.serialize_field("architectures", &self.architectures)?; + } + if !self.syscalls.is_empty() { + struct_ser.serialize_field("syscalls", &self.syscalls)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelIpv4ServerSocketInfo { +impl<'de> serde::Deserialize<'de> for ResolvedSeccompProfile { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "local_ip", - "localIp", - "local_port", - "localPort", - "protocol", + "default_action", + "defaultAction", + "default_errno_ret", + "defaultErrnoRet", + "architectures", + "syscalls", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - LocalIp, - LocalPort, - Protocol, + DefaultAction, + DefaultErrnoRet, + Architectures, + Syscalls, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -16151,9 +16254,10 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelIpv4ServerSocketInfo { E: serde::de::Error, { match value { - "localIp" | "local_ip" => Ok(GeneratedField::LocalIp), - "localPort" | "local_port" => Ok(GeneratedField::LocalPort), - "protocol" => Ok(GeneratedField::Protocol), + "defaultAction" | "default_action" => Ok(GeneratedField::DefaultAction), + "defaultErrnoRet" | "default_errno_ret" => Ok(GeneratedField::DefaultErrnoRet), + "architectures" => Ok(GeneratedField::Architectures), + "syscalls" => Ok(GeneratedField::Syscalls), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -16163,54 +16267,62 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelIpv4ServerSocketInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelIpv4ServerSocketInfo; + type Value = ResolvedSeccompProfile; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelIpv4ServerSocketInfo") + formatter.write_str("struct protect.control.v1.ResolvedSeccompProfile") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut local_ip__ = None; - let mut local_port__ = None; - let mut protocol__ = None; + let mut default_action__ = None; + let mut default_errno_ret__ = None; + let mut architectures__ = None; + let mut syscalls__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::LocalIp => { - if local_ip__.is_some() { - return Err(serde::de::Error::duplicate_field("localIp")); + GeneratedField::DefaultAction => { + if default_action__.is_some() { + return Err(serde::de::Error::duplicate_field("defaultAction")); } - local_ip__ = Some(map_.next_value()?); + default_action__ = Some(map_.next_value()?); } - GeneratedField::LocalPort => { - if local_port__.is_some() { - return Err(serde::de::Error::duplicate_field("localPort")); + GeneratedField::DefaultErrnoRet => { + if default_errno_ret__.is_some() { + return Err(serde::de::Error::duplicate_field("defaultErrnoRet")); } - local_port__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + default_errno_ret__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) ; } - GeneratedField::Protocol => { - if protocol__.is_some() { - return Err(serde::de::Error::duplicate_field("protocol")); + GeneratedField::Architectures => { + if architectures__.is_some() { + return Err(serde::de::Error::duplicate_field("architectures")); } - protocol__ = Some(map_.next_value::()? as i32); + architectures__ = Some(map_.next_value()?); + } + GeneratedField::Syscalls => { + if syscalls__.is_some() { + return Err(serde::de::Error::duplicate_field("syscalls")); + } + syscalls__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelIpv4ServerSocketInfo { - local_ip: local_ip__.unwrap_or_default(), - local_port: local_port__.unwrap_or_default(), - protocol: protocol__.unwrap_or_default(), + Ok(ResolvedSeccompProfile { + default_action: default_action__.unwrap_or_default(), + default_errno_ret: default_errno_ret__, + architectures: architectures__.unwrap_or_default(), + syscalls: syscalls__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelIpv4ServerSocketInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolvedSeccompProfile", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelIpv4SocketInfo { +impl serde::Serialize for ResolvedSeccompSyscallArg { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -16218,67 +16330,58 @@ impl serde::Serialize for ZoneKernelIpv4SocketInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.source_ip.is_empty() { + if self.index != 0 { len += 1; } - if !self.dest_ip.is_empty() { - len += 1; - } - if self.source_port != 0 { + if self.value != 0 { len += 1; } - if self.dest_port != 0 { + if self.value_two.is_some() { len += 1; } - if self.protocol != 0 { + if !self.op.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelIpv4SocketInfo", len)?; - if !self.source_ip.is_empty() { - struct_ser.serialize_field("sourceIp", &self.source_ip)?; - } - if !self.dest_ip.is_empty() { - struct_ser.serialize_field("destIp", &self.dest_ip)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolvedSeccompSyscallArg", len)?; + if self.index != 0 { + struct_ser.serialize_field("index", &self.index)?; } - if self.source_port != 0 { - struct_ser.serialize_field("sourcePort", &self.source_port)?; + if self.value != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("value", ToString::to_string(&self.value).as_str())?; } - if self.dest_port != 0 { - struct_ser.serialize_field("destPort", &self.dest_port)?; + if let Some(v) = self.value_two.as_ref() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("valueTwo", ToString::to_string(&v).as_str())?; } - if self.protocol != 0 { - let v = ZoneKernelIpProtocol::try_from(self.protocol) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.protocol)))?; - struct_ser.serialize_field("protocol", &v)?; + if !self.op.is_empty() { + struct_ser.serialize_field("op", &self.op)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelIpv4SocketInfo { +impl<'de> serde::Deserialize<'de> for ResolvedSeccompSyscallArg { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "source_ip", - "sourceIp", - "dest_ip", - "destIp", - "source_port", - "sourcePort", - "dest_port", - "destPort", - "protocol", + "index", + "value", + "value_two", + "valueTwo", + "op", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - SourceIp, - DestIp, - SourcePort, - DestPort, - Protocol, + Index, + Value, + ValueTwo, + Op, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -16300,11 +16403,10 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelIpv4SocketInfo { E: serde::de::Error, { match value { - "sourceIp" | "source_ip" => Ok(GeneratedField::SourceIp), - "destIp" | "dest_ip" => Ok(GeneratedField::DestIp), - "sourcePort" | "source_port" => Ok(GeneratedField::SourcePort), - "destPort" | "dest_port" => Ok(GeneratedField::DestPort), - "protocol" => Ok(GeneratedField::Protocol), + "index" => Ok(GeneratedField::Index), + "value" => Ok(GeneratedField::Value), + "valueTwo" | "value_two" => Ok(GeneratedField::ValueTwo), + "op" => Ok(GeneratedField::Op), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -16314,72 +16416,66 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelIpv4SocketInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelIpv4SocketInfo; + type Value = ResolvedSeccompSyscallArg; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelIpv4SocketInfo") + formatter.write_str("struct protect.control.v1.ResolvedSeccompSyscallArg") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut source_ip__ = None; - let mut dest_ip__ = None; - let mut source_port__ = None; - let mut dest_port__ = None; - let mut protocol__ = None; + let mut index__ = None; + let mut value__ = None; + let mut value_two__ = None; + let mut op__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::SourceIp => { - if source_ip__.is_some() { - return Err(serde::de::Error::duplicate_field("sourceIp")); - } - source_ip__ = Some(map_.next_value()?); - } - GeneratedField::DestIp => { - if dest_ip__.is_some() { - return Err(serde::de::Error::duplicate_field("destIp")); + GeneratedField::Index => { + if index__.is_some() { + return Err(serde::de::Error::duplicate_field("index")); } - dest_ip__ = Some(map_.next_value()?); + index__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::SourcePort => { - if source_port__.is_some() { - return Err(serde::de::Error::duplicate_field("sourcePort")); + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); } - source_port__ = + value__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::DestPort => { - if dest_port__.is_some() { - return Err(serde::de::Error::duplicate_field("destPort")); + GeneratedField::ValueTwo => { + if value_two__.is_some() { + return Err(serde::de::Error::duplicate_field("valueTwo")); } - dest_port__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + value_two__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) ; } - GeneratedField::Protocol => { - if protocol__.is_some() { - return Err(serde::de::Error::duplicate_field("protocol")); + GeneratedField::Op => { + if op__.is_some() { + return Err(serde::de::Error::duplicate_field("op")); } - protocol__ = Some(map_.next_value::()? as i32); + op__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelIpv4SocketInfo { - source_ip: source_ip__.unwrap_or_default(), - dest_ip: dest_ip__.unwrap_or_default(), - source_port: source_port__.unwrap_or_default(), - dest_port: dest_port__.unwrap_or_default(), - protocol: protocol__.unwrap_or_default(), + Ok(ResolvedSeccompSyscallArg { + index: index__.unwrap_or_default(), + value: value__.unwrap_or_default(), + value_two: value_two__, + op: op__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelIpv4SocketInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolvedSeccompSyscallArg", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelIpv6ServerSocketInfo { +impl serde::Serialize for ResolvedSeccompSyscallRule { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -16387,49 +16483,54 @@ impl serde::Serialize for ZoneKernelIpv6ServerSocketInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.local_ip.is_empty() { + if !self.names.is_empty() { len += 1; } - if self.local_port != 0 { + if !self.action.is_empty() { len += 1; } - if self.protocol != 0 { + if self.errno_ret.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelIpv6ServerSocketInfo", len)?; - if !self.local_ip.is_empty() { - struct_ser.serialize_field("localIp", &self.local_ip)?; + if !self.args.is_empty() { + len += 1; } - if self.local_port != 0 { - struct_ser.serialize_field("localPort", &self.local_port)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResolvedSeccompSyscallRule", len)?; + if !self.names.is_empty() { + struct_ser.serialize_field("names", &self.names)?; } - if self.protocol != 0 { - let v = ZoneKernelIpProtocol::try_from(self.protocol) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.protocol)))?; - struct_ser.serialize_field("protocol", &v)?; + if !self.action.is_empty() { + struct_ser.serialize_field("action", &self.action)?; + } + if let Some(v) = self.errno_ret.as_ref() { + struct_ser.serialize_field("errnoRet", v)?; + } + if !self.args.is_empty() { + struct_ser.serialize_field("args", &self.args)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelIpv6ServerSocketInfo { +impl<'de> serde::Deserialize<'de> for ResolvedSeccompSyscallRule { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "local_ip", - "localIp", - "local_port", - "localPort", - "protocol", + "names", + "action", + "errno_ret", + "errnoRet", + "args", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - LocalIp, - LocalPort, - Protocol, + Names, + Action, + ErrnoRet, + Args, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -16451,9 +16552,10 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelIpv6ServerSocketInfo { E: serde::de::Error, { match value { - "localIp" | "local_ip" => Ok(GeneratedField::LocalIp), - "localPort" | "local_port" => Ok(GeneratedField::LocalPort), - "protocol" => Ok(GeneratedField::Protocol), + "names" => Ok(GeneratedField::Names), + "action" => Ok(GeneratedField::Action), + "errnoRet" | "errno_ret" => Ok(GeneratedField::ErrnoRet), + "args" => Ok(GeneratedField::Args), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -16463,54 +16565,62 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelIpv6ServerSocketInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelIpv6ServerSocketInfo; + type Value = ResolvedSeccompSyscallRule; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelIpv6ServerSocketInfo") + formatter.write_str("struct protect.control.v1.ResolvedSeccompSyscallRule") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut local_ip__ = None; - let mut local_port__ = None; - let mut protocol__ = None; + let mut names__ = None; + let mut action__ = None; + let mut errno_ret__ = None; + let mut args__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::LocalIp => { - if local_ip__.is_some() { - return Err(serde::de::Error::duplicate_field("localIp")); + GeneratedField::Names => { + if names__.is_some() { + return Err(serde::de::Error::duplicate_field("names")); } - local_ip__ = Some(map_.next_value()?); + names__ = Some(map_.next_value()?); } - GeneratedField::LocalPort => { - if local_port__.is_some() { - return Err(serde::de::Error::duplicate_field("localPort")); + GeneratedField::Action => { + if action__.is_some() { + return Err(serde::de::Error::duplicate_field("action")); } - local_port__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + action__ = Some(map_.next_value()?); + } + GeneratedField::ErrnoRet => { + if errno_ret__.is_some() { + return Err(serde::de::Error::duplicate_field("errnoRet")); + } + errno_ret__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) ; } - GeneratedField::Protocol => { - if protocol__.is_some() { - return Err(serde::de::Error::duplicate_field("protocol")); + GeneratedField::Args => { + if args__.is_some() { + return Err(serde::de::Error::duplicate_field("args")); } - protocol__ = Some(map_.next_value::()? as i32); + args__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelIpv6ServerSocketInfo { - local_ip: local_ip__.unwrap_or_default(), - local_port: local_port__.unwrap_or_default(), - protocol: protocol__.unwrap_or_default(), + Ok(ResolvedSeccompSyscallRule { + names: names__.unwrap_or_default(), + action: action__.unwrap_or_default(), + errno_ret: errno_ret__, + args: args__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelIpv6ServerSocketInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResolvedSeccompSyscallRule", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelIpv6SocketInfo { +impl serde::Serialize for ResourceOrigin { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -16518,67 +16628,48 @@ impl serde::Serialize for ZoneKernelIpv6SocketInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.source_ip.is_empty() { - len += 1; - } - if !self.dest_ip.is_empty() { - len += 1; - } - if self.source_port != 0 { + if !self.zone_id.is_empty() { len += 1; } - if self.dest_port != 0 { + if !self.workload_id.is_empty() { len += 1; } - if self.protocol != 0 { + if !self.user_agent.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelIpv6SocketInfo", len)?; - if !self.source_ip.is_empty() { - struct_ser.serialize_field("sourceIp", &self.source_ip)?; - } - if !self.dest_ip.is_empty() { - struct_ser.serialize_field("destIp", &self.dest_ip)?; - } - if self.source_port != 0 { - struct_ser.serialize_field("sourcePort", &self.source_port)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResourceOrigin", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } - if self.dest_port != 0 { - struct_ser.serialize_field("destPort", &self.dest_port)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; } - if self.protocol != 0 { - let v = ZoneKernelIpProtocol::try_from(self.protocol) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.protocol)))?; - struct_ser.serialize_field("protocol", &v)?; + if !self.user_agent.is_empty() { + struct_ser.serialize_field("userAgent", &self.user_agent)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelIpv6SocketInfo { +impl<'de> serde::Deserialize<'de> for ResourceOrigin { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "source_ip", - "sourceIp", - "dest_ip", - "destIp", - "source_port", - "sourcePort", - "dest_port", - "destPort", - "protocol", + "zone_id", + "zoneId", + "workload_id", + "workloadId", + "user_agent", + "userAgent", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - SourceIp, - DestIp, - SourcePort, - DestPort, - Protocol, + ZoneId, + WorkloadId, + UserAgent, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -16600,11 +16691,9 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelIpv6SocketInfo { E: serde::de::Error, { match value { - "sourceIp" | "source_ip" => Ok(GeneratedField::SourceIp), - "destIp" | "dest_ip" => Ok(GeneratedField::DestIp), - "sourcePort" | "source_port" => Ok(GeneratedField::SourcePort), - "destPort" | "dest_port" => Ok(GeneratedField::DestPort), - "protocol" => Ok(GeneratedField::Protocol), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "userAgent" | "user_agent" => Ok(GeneratedField::UserAgent), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -16614,72 +16703,52 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelIpv6SocketInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelIpv6SocketInfo; + type Value = ResourceOrigin; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelIpv6SocketInfo") + formatter.write_str("struct protect.control.v1.ResourceOrigin") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut source_ip__ = None; - let mut dest_ip__ = None; - let mut source_port__ = None; - let mut dest_port__ = None; - let mut protocol__ = None; + let mut zone_id__ = None; + let mut workload_id__ = None; + let mut user_agent__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::SourceIp => { - if source_ip__.is_some() { - return Err(serde::de::Error::duplicate_field("sourceIp")); - } - source_ip__ = Some(map_.next_value()?); - } - GeneratedField::DestIp => { - if dest_ip__.is_some() { - return Err(serde::de::Error::duplicate_field("destIp")); - } - dest_ip__ = Some(map_.next_value()?); - } - GeneratedField::SourcePort => { - if source_port__.is_some() { - return Err(serde::de::Error::duplicate_field("sourcePort")); + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - source_port__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + zone_id__ = Some(map_.next_value()?); } - GeneratedField::DestPort => { - if dest_port__.is_some() { - return Err(serde::de::Error::duplicate_field("destPort")); + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); } - dest_port__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + workload_id__ = Some(map_.next_value()?); } - GeneratedField::Protocol => { - if protocol__.is_some() { - return Err(serde::de::Error::duplicate_field("protocol")); + GeneratedField::UserAgent => { + if user_agent__.is_some() { + return Err(serde::de::Error::duplicate_field("userAgent")); } - protocol__ = Some(map_.next_value::()? as i32); + user_agent__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelIpv6SocketInfo { - source_ip: source_ip__.unwrap_or_default(), - dest_ip: dest_ip__.unwrap_or_default(), - source_port: source_port__.unwrap_or_default(), - dest_port: dest_port__.unwrap_or_default(), - protocol: protocol__.unwrap_or_default(), + Ok(ResourceOrigin { + zone_id: zone_id__.unwrap_or_default(), + workload_id: workload_id__.unwrap_or_default(), + user_agent: user_agent__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelIpv6SocketInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ResourceOrigin", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelPidFd { +impl serde::Serialize for RestoreClaim { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -16687,31 +16756,37 @@ impl serde::Serialize for ZoneKernelPidFd { { use serde::ser::SerializeStruct; let mut len = 0; - if self.pid != 0 { + if !self.claim.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelPidFd", len)?; - if self.pid != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("pid", ToString::to_string(&self.pid).as_str())?; + if !self.annotations.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.RestoreClaim", len)?; + if !self.claim.is_empty() { + struct_ser.serialize_field("claim", &self.claim)?; + } + if !self.annotations.is_empty() { + struct_ser.serialize_field("annotations", &self.annotations)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelPidFd { +impl<'de> serde::Deserialize<'de> for RestoreClaim { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "pid", + "claim", + "annotations", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Pid, + Claim, + Annotations, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -16733,7 +16808,8 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelPidFd { E: serde::de::Error, { match value { - "pid" => Ok(GeneratedField::Pid), + "claim" => Ok(GeneratedField::Claim), + "annotations" => Ok(GeneratedField::Annotations), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -16743,38 +16819,44 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelPidFd { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelPidFd; + type Value = RestoreClaim; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelPidFd") + formatter.write_str("struct protect.control.v1.RestoreClaim") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut pid__ = None; + let mut claim__ = None; + let mut annotations__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Pid => { - if pid__.is_some() { - return Err(serde::de::Error::duplicate_field("pid")); + GeneratedField::Claim => { + if claim__.is_some() { + return Err(serde::de::Error::duplicate_field("claim")); } - pid__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + claim__ = Some(map_.next_value()?); + } + GeneratedField::Annotations => { + if annotations__.is_some() { + return Err(serde::de::Error::duplicate_field("annotations")); + } + annotations__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelPidFd { - pid: pid__.unwrap_or_default(), + Ok(RestoreClaim { + claim: claim__.unwrap_or_default(), + annotations: annotations__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelPidFd", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.RestoreClaim", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelRegularFileInfo { +impl serde::Serialize for RestoredBinding { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -16782,55 +16864,75 @@ impl serde::Serialize for ZoneKernelRegularFileInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if self.open_flags != 0 { + if !self.workload_id.is_empty() { len += 1; } - if !self.name.is_empty() { + if !self.target_path.is_empty() { len += 1; } - if self.mount_id != 0 { + if !self.host_path.is_empty() { len += 1; } - if self.device != 0 { + if self.placeholder != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelRegularFileInfo", len)?; - if self.open_flags != 0 { - struct_ser.serialize_field("openFlags", &self.open_flags)?; + if self.fill { + len += 1; } - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; + if !self.spec_host_path.is_empty() { + len += 1; } - if self.mount_id != 0 { - struct_ser.serialize_field("mountId", &self.mount_id)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.RestoredBinding", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; } - if self.device != 0 { - struct_ser.serialize_field("device", &self.device)?; + if !self.target_path.is_empty() { + struct_ser.serialize_field("targetPath", &self.target_path)?; + } + if !self.host_path.is_empty() { + struct_ser.serialize_field("hostPath", &self.host_path)?; + } + if self.placeholder != 0 { + let v = RestoredPlaceholder::try_from(self.placeholder) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.placeholder)))?; + struct_ser.serialize_field("placeholder", &v)?; + } + if self.fill { + struct_ser.serialize_field("fill", &self.fill)?; + } + if !self.spec_host_path.is_empty() { + struct_ser.serialize_field("specHostPath", &self.spec_host_path)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelRegularFileInfo { +impl<'de> serde::Deserialize<'de> for RestoredBinding { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "open_flags", - "openFlags", - "name", - "mount_id", - "mountId", - "device", + "workload_id", + "workloadId", + "target_path", + "targetPath", + "host_path", + "hostPath", + "placeholder", + "fill", + "spec_host_path", + "specHostPath", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - OpenFlags, - Name, - MountId, - Device, + WorkloadId, + TargetPath, + HostPath, + Placeholder, + Fill, + SpecHostPath, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -16852,10 +16954,12 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelRegularFileInfo { E: serde::de::Error, { match value { - "openFlags" | "open_flags" => Ok(GeneratedField::OpenFlags), - "name" => Ok(GeneratedField::Name), - "mountId" | "mount_id" => Ok(GeneratedField::MountId), - "device" => Ok(GeneratedField::Device), + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "targetPath" | "target_path" => Ok(GeneratedField::TargetPath), + "hostPath" | "host_path" => Ok(GeneratedField::HostPath), + "placeholder" => Ok(GeneratedField::Placeholder), + "fill" => Ok(GeneratedField::Fill), + "specHostPath" | "spec_host_path" => Ok(GeneratedField::SpecHostPath), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -16865,66 +16969,76 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelRegularFileInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelRegularFileInfo; + type Value = RestoredBinding; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelRegularFileInfo") + formatter.write_str("struct protect.control.v1.RestoredBinding") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut open_flags__ = None; - let mut name__ = None; - let mut mount_id__ = None; - let mut device__ = None; + let mut workload_id__ = None; + let mut target_path__ = None; + let mut host_path__ = None; + let mut placeholder__ = None; + let mut fill__ = None; + let mut spec_host_path__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::OpenFlags => { - if open_flags__.is_some() { - return Err(serde::de::Error::duplicate_field("openFlags")); + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); } - open_flags__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + workload_id__ = Some(map_.next_value()?); } - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); + GeneratedField::TargetPath => { + if target_path__.is_some() { + return Err(serde::de::Error::duplicate_field("targetPath")); } - name__ = Some(map_.next_value()?); + target_path__ = Some(map_.next_value()?); } - GeneratedField::MountId => { - if mount_id__.is_some() { - return Err(serde::de::Error::duplicate_field("mountId")); + GeneratedField::HostPath => { + if host_path__.is_some() { + return Err(serde::de::Error::duplicate_field("hostPath")); } - mount_id__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + host_path__ = Some(map_.next_value()?); } - GeneratedField::Device => { - if device__.is_some() { - return Err(serde::de::Error::duplicate_field("device")); + GeneratedField::Placeholder => { + if placeholder__.is_some() { + return Err(serde::de::Error::duplicate_field("placeholder")); } - device__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + placeholder__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Fill => { + if fill__.is_some() { + return Err(serde::de::Error::duplicate_field("fill")); + } + fill__ = Some(map_.next_value()?); + } + GeneratedField::SpecHostPath => { + if spec_host_path__.is_some() { + return Err(serde::de::Error::duplicate_field("specHostPath")); + } + spec_host_path__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelRegularFileInfo { - open_flags: open_flags__.unwrap_or_default(), - name: name__.unwrap_or_default(), - mount_id: mount_id__.unwrap_or_default(), - device: device__.unwrap_or_default(), + Ok(RestoredBinding { + workload_id: workload_id__.unwrap_or_default(), + target_path: target_path__.unwrap_or_default(), + host_path: host_path__.unwrap_or_default(), + placeholder: placeholder__.unwrap_or_default(), + fill: fill__.unwrap_or_default(), + spec_host_path: spec_host_path__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelRegularFileInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.RestoredBinding", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelSyscallEvent { +impl serde::Serialize for RestoredMount { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -16932,113 +17046,65 @@ impl serde::Serialize for ZoneKernelSyscallEvent { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { - len += 1; - } - if self.timestamp != 0 { - len += 1; - } - if self.thread_id != 0 { - len += 1; - } - if self.event_length != 0 { - len += 1; - } - if !self.event_name.is_empty() { - len += 1; - } - if !self.event_category.is_empty() { + if !self.target_path.is_empty() { len += 1; } - if self.event_flags != 0 { + if self.read_only { len += 1; } - if self.event_type != 0 { + if !self.recorded_host_path.is_empty() { len += 1; } - if self.cpuid != 0 { + if self.captured { len += 1; } - if !self.event_params.is_empty() { + if !self.recorded_spec_host_path.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelSyscallEvent", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; - } - if self.timestamp != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?; - } - if self.thread_id != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("threadId", ToString::to_string(&self.thread_id).as_str())?; - } - if self.event_length != 0 { - struct_ser.serialize_field("eventLength", &self.event_length)?; - } - if !self.event_name.is_empty() { - struct_ser.serialize_field("eventName", &self.event_name)?; - } - if !self.event_category.is_empty() { - struct_ser.serialize_field("eventCategory", &self.event_category)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.RestoredMount", len)?; + if !self.target_path.is_empty() { + struct_ser.serialize_field("targetPath", &self.target_path)?; } - if self.event_flags != 0 { - struct_ser.serialize_field("eventFlags", &self.event_flags)?; + if self.read_only { + struct_ser.serialize_field("readOnly", &self.read_only)?; } - if self.event_type != 0 { - struct_ser.serialize_field("eventType", &self.event_type)?; + if !self.recorded_host_path.is_empty() { + struct_ser.serialize_field("recordedHostPath", &self.recorded_host_path)?; } - if self.cpuid != 0 { - struct_ser.serialize_field("cpuid", &self.cpuid)?; + if self.captured { + struct_ser.serialize_field("captured", &self.captured)?; } - if !self.event_params.is_empty() { - struct_ser.serialize_field("eventParams", &self.event_params)?; + if !self.recorded_spec_host_path.is_empty() { + struct_ser.serialize_field("recordedSpecHostPath", &self.recorded_spec_host_path)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelSyscallEvent { +impl<'de> serde::Deserialize<'de> for RestoredMount { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", - "timestamp", - "thread_id", - "threadId", - "event_length", - "eventLength", - "event_name", - "eventName", - "event_category", - "eventCategory", - "event_flags", - "eventFlags", - "event_type", - "eventType", - "cpuid", - "event_params", - "eventParams", + "target_path", + "targetPath", + "read_only", + "readOnly", + "recorded_host_path", + "recordedHostPath", + "captured", + "recorded_spec_host_path", + "recordedSpecHostPath", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, - Timestamp, - ThreadId, - EventLength, - EventName, - EventCategory, - EventFlags, - EventType, - Cpuid, - EventParams, + TargetPath, + ReadOnly, + RecordedHostPath, + Captured, + RecordedSpecHostPath, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -17060,16 +17126,11 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelSyscallEvent { E: serde::de::Error, { match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - "timestamp" => Ok(GeneratedField::Timestamp), - "threadId" | "thread_id" => Ok(GeneratedField::ThreadId), - "eventLength" | "event_length" => Ok(GeneratedField::EventLength), - "eventName" | "event_name" => Ok(GeneratedField::EventName), - "eventCategory" | "event_category" => Ok(GeneratedField::EventCategory), - "eventFlags" | "event_flags" => Ok(GeneratedField::EventFlags), - "eventType" | "event_type" => Ok(GeneratedField::EventType), - "cpuid" => Ok(GeneratedField::Cpuid), - "eventParams" | "event_params" => Ok(GeneratedField::EventParams), + "targetPath" | "target_path" => Ok(GeneratedField::TargetPath), + "readOnly" | "read_only" => Ok(GeneratedField::ReadOnly), + "recordedHostPath" | "recorded_host_path" => Ok(GeneratedField::RecordedHostPath), + "captured" => Ok(GeneratedField::Captured), + "recordedSpecHostPath" | "recorded_spec_host_path" => Ok(GeneratedField::RecordedSpecHostPath), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -17079,120 +17140,142 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelSyscallEvent { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelSyscallEvent; + type Value = RestoredMount; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelSyscallEvent") + formatter.write_str("struct protect.control.v1.RestoredMount") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - let mut timestamp__ = None; - let mut thread_id__ = None; - let mut event_length__ = None; - let mut event_name__ = None; - let mut event_category__ = None; - let mut event_flags__ = None; - let mut event_type__ = None; - let mut cpuid__ = None; - let mut event_params__ = None; + let mut target_path__ = None; + let mut read_only__ = None; + let mut recorded_host_path__ = None; + let mut captured__ = None; + let mut recorded_spec_host_path__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); - } - zone_id__ = Some(map_.next_value()?); - } - GeneratedField::Timestamp => { - if timestamp__.is_some() { - return Err(serde::de::Error::duplicate_field("timestamp")); + GeneratedField::TargetPath => { + if target_path__.is_some() { + return Err(serde::de::Error::duplicate_field("targetPath")); } - timestamp__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + target_path__ = Some(map_.next_value()?); } - GeneratedField::ThreadId => { - if thread_id__.is_some() { - return Err(serde::de::Error::duplicate_field("threadId")); + GeneratedField::ReadOnly => { + if read_only__.is_some() { + return Err(serde::de::Error::duplicate_field("readOnly")); } - thread_id__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + read_only__ = Some(map_.next_value()?); } - GeneratedField::EventLength => { - if event_length__.is_some() { - return Err(serde::de::Error::duplicate_field("eventLength")); + GeneratedField::RecordedHostPath => { + if recorded_host_path__.is_some() { + return Err(serde::de::Error::duplicate_field("recordedHostPath")); } - event_length__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + recorded_host_path__ = Some(map_.next_value()?); } - GeneratedField::EventName => { - if event_name__.is_some() { - return Err(serde::de::Error::duplicate_field("eventName")); + GeneratedField::Captured => { + if captured__.is_some() { + return Err(serde::de::Error::duplicate_field("captured")); } - event_name__ = Some(map_.next_value()?); + captured__ = Some(map_.next_value()?); } - GeneratedField::EventCategory => { - if event_category__.is_some() { - return Err(serde::de::Error::duplicate_field("eventCategory")); + GeneratedField::RecordedSpecHostPath => { + if recorded_spec_host_path__.is_some() { + return Err(serde::de::Error::duplicate_field("recordedSpecHostPath")); } - event_category__ = Some(map_.next_value()?); - } - GeneratedField::EventFlags => { - if event_flags__.is_some() { - return Err(serde::de::Error::duplicate_field("eventFlags")); - } - event_flags__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::EventType => { - if event_type__.is_some() { - return Err(serde::de::Error::duplicate_field("eventType")); - } - event_type__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Cpuid => { - if cpuid__.is_some() { - return Err(serde::de::Error::duplicate_field("cpuid")); - } - cpuid__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::EventParams => { - if event_params__.is_some() { - return Err(serde::de::Error::duplicate_field("eventParams")); - } - event_params__ = Some(map_.next_value()?); + recorded_spec_host_path__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelSyscallEvent { - zone_id: zone_id__.unwrap_or_default(), - timestamp: timestamp__.unwrap_or_default(), - thread_id: thread_id__.unwrap_or_default(), - event_length: event_length__.unwrap_or_default(), - event_name: event_name__.unwrap_or_default(), - event_category: event_category__.unwrap_or_default(), - event_flags: event_flags__.unwrap_or_default(), - event_type: event_type__.unwrap_or_default(), - cpuid: cpuid__.unwrap_or_default(), - event_params: event_params__.unwrap_or_default(), + Ok(RestoredMount { + target_path: target_path__.unwrap_or_default(), + read_only: read_only__.unwrap_or_default(), + recorded_host_path: recorded_host_path__.unwrap_or_default(), + captured: captured__.unwrap_or_default(), + recorded_spec_host_path: recorded_spec_host_path__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelSyscallEvent", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.RestoredMount", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelThreadInfo { +impl serde::Serialize for RestoredPlaceholder { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unspecified => "RESTORED_PLACEHOLDER_UNSPECIFIED", + Self::File => "RESTORED_PLACEHOLDER_FILE", + Self::Directory => "RESTORED_PLACEHOLDER_DIRECTORY", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for RestoredPlaceholder { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "RESTORED_PLACEHOLDER_UNSPECIFIED", + "RESTORED_PLACEHOLDER_FILE", + "RESTORED_PLACEHOLDER_DIRECTORY", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = RestoredPlaceholder; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "RESTORED_PLACEHOLDER_UNSPECIFIED" => Ok(RestoredPlaceholder::Unspecified), + "RESTORED_PLACEHOLDER_FILE" => Ok(RestoredPlaceholder::File), + "RESTORED_PLACEHOLDER_DIRECTORY" => Ok(RestoredPlaceholder::Directory), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for RestoredWorkload { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -17200,444 +17283,973 @@ impl serde::Serialize for ZoneKernelThreadInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if self.tid.is_some() { - len += 1; - } - if self.pid.is_some() { - len += 1; - } - if self.ptid.is_some() { - len += 1; - } - if self.sid != 0 { - len += 1; - } - if self.vpgid != 0 { - len += 1; - } - if self.pgid != 0 { - len += 1; - } - if !self.comm.is_empty() { - len += 1; - } - if !self.exe.is_empty() { + if !self.workload_id.is_empty() { len += 1; } - if !self.exepath.is_empty() { + if !self.image.is_empty() { len += 1; } - if self.exe_writable { + if !self.annotations.is_empty() { len += 1; } - if self.exe_upper_layer { + if !self.mounts.is_empty() { len += 1; } - if self.exe_lower_layer { - len += 1; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.RestoredWorkload", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; } - if self.exe_from_memfd { - len += 1; + if !self.image.is_empty() { + struct_ser.serialize_field("image", &self.image)?; } - if !self.args.is_empty() { - len += 1; + if !self.annotations.is_empty() { + struct_ser.serialize_field("annotations", &self.annotations)?; } - if !self.env.is_empty() { - len += 1; + if !self.mounts.is_empty() { + struct_ser.serialize_field("mounts", &self.mounts)?; } - if !self.cwd.is_empty() { - len += 1; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for RestoredWorkload { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "workload_id", + "workloadId", + "image", + "annotations", + "mounts", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WorkloadId, + Image, + Annotations, + Mounts, } - if self.fdlimit != 0 { - len += 1; + 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 { + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "image" => Ok(GeneratedField::Image), + "annotations" => Ok(GeneratedField::Annotations), + "mounts" => Ok(GeneratedField::Mounts), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if self.flags != 0 { - len += 1; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = RestoredWorkload; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.RestoredWorkload") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut workload_id__ = None; + let mut image__ = None; + let mut annotations__ = None; + let mut mounts__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); + } + workload_id__ = Some(map_.next_value()?); + } + GeneratedField::Image => { + if image__.is_some() { + return Err(serde::de::Error::duplicate_field("image")); + } + image__ = Some(map_.next_value()?); + } + GeneratedField::Annotations => { + if annotations__.is_some() { + return Err(serde::de::Error::duplicate_field("annotations")); + } + annotations__ = Some(map_.next_value()?); + } + GeneratedField::Mounts => { + if mounts__.is_some() { + return Err(serde::de::Error::duplicate_field("mounts")); + } + mounts__ = Some(map_.next_value()?); + } + } + } + Ok(RestoredWorkload { + workload_id: workload_id__.unwrap_or_default(), + image: image__.unwrap_or_default(), + annotations: annotations__.unwrap_or_default(), + mounts: mounts__.unwrap_or_default(), + }) + } } - if self.uid != 0 { - len += 1; - } - if self.gid != 0 { - len += 1; + deserializer.deserialize_struct("protect.control.v1.RestoredWorkload", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ResumeZoneReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ResumeZoneReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ResumeZoneReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { } - if self.cap_permitted != 0 { - len += 1; + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if self.cap_effective != 0 { - len += 1; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ResumeZoneReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ResumeZoneReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(ResumeZoneReply { + }) + } } - if self.cap_inheritable != 0 { + deserializer.deserialize_struct("protect.control.v1.ResumeZoneReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ResumeZoneRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { len += 1; } - if self.exe_ino != 0 { - len += 1; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ResumeZoneRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } - if self.exe_ino_ctime != 0 { - len += 1; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ResumeZoneRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, } - if self.exe_ino_mtime != 0 { - len += 1; + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if self.exe_ino_ctime_duration_clone_ts != 0 { - len += 1; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ResumeZoneRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ResumeZoneRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + } + } + Ok(ResumeZoneRequest { + zone_id: zone_id__.unwrap_or_default(), + }) + } } - if self.exe_ino_ctime_duration_pidns_start != 0 { - len += 1; + deserializer.deserialize_struct("protect.control.v1.ResumeZoneRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SeccompProfileType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unconfined => "SECCOMP_PROFILE_TYPE_UNCONFINED", + Self::RuntimeDefault => "SECCOMP_PROFILE_TYPE_RUNTIME_DEFAULT", + Self::Localhost => "SECCOMP_PROFILE_TYPE_LOCALHOST", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for SeccompProfileType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "SECCOMP_PROFILE_TYPE_UNCONFINED", + "SECCOMP_PROFILE_TYPE_RUNTIME_DEFAULT", + "SECCOMP_PROFILE_TYPE_LOCALHOST", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SeccompProfileType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "SECCOMP_PROFILE_TYPE_UNCONFINED" => Ok(SeccompProfileType::Unconfined), + "SECCOMP_PROFILE_TYPE_RUNTIME_DEFAULT" => Ok(SeccompProfileType::RuntimeDefault), + "SECCOMP_PROFILE_TYPE_LOCALHOST" => Ok(SeccompProfileType::Localhost), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } } - if self.vmsize_kb != 0 { + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ServiceEntry { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { len += 1; } - if self.vmrss_kb != 0 { + if !self.service_name.is_empty() { len += 1; } - if self.vmswap_kb != 0 { - len += 1; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ServiceEntry", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } - if self.pfmajor != 0 { - len += 1; + if !self.service_name.is_empty() { + struct_ser.serialize_field("serviceName", &self.service_name)?; } - if self.pfminor != 0 { - len += 1; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ServiceEntry { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "service_name", + "serviceName", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + ServiceName, } - if self.vtid.is_some() { - len += 1; - } - if self.vpid.is_some() { - len += 1; - } - if self.pidns_init_start_ts != 0 { - len += 1; - } - if !self.cgroups.is_empty() { - len += 1; + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "serviceName" | "service_name" => Ok(GeneratedField::ServiceName), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if !self.root.is_empty() { - len += 1; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ServiceEntry; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ServiceEntry") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut service_name__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::ServiceName => { + if service_name__.is_some() { + return Err(serde::de::Error::duplicate_field("serviceName")); + } + service_name__ = Some(map_.next_value()?); + } + } + } + Ok(ServiceEntry { + zone_id: zone_id__.unwrap_or_default(), + service_name: service_name__.unwrap_or_default(), + }) + } } - if self.filtered_out { - len += 1; + deserializer.deserialize_struct("protect.control.v1.ServiceEntry", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SetHostPowerManagementPolicyReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.SetHostPowerManagementPolicyReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SetHostPowerManagementPolicyReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { } - if !self.fdlist.is_empty() { - len += 1; + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if self.clone_ts != 0 { - len += 1; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SetHostPowerManagementPolicyReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SetHostPowerManagementPolicyReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(SetHostPowerManagementPolicyReply { + }) + } } - if self.tty != 0 { + deserializer.deserialize_struct("protect.control.v1.SetHostPowerManagementPolicyReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SetHostPowerManagementPolicyRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.scheduler.is_empty() { len += 1; } - if self.loginuid != 0 { + if self.smt_awareness { len += 1; } - if self.lastexec_ts != 0 { - len += 1; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.SetHostPowerManagementPolicyRequest", len)?; + if !self.scheduler.is_empty() { + struct_ser.serialize_field("scheduler", &self.scheduler)?; } - if self.reaper { - len += 1; + if self.smt_awareness { + struct_ser.serialize_field("smtAwareness", &self.smt_awareness)?; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelThreadInfo", len)?; - if let Some(v) = self.tid.as_ref() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("tid", ToString::to_string(&v).as_str())?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SetHostPowerManagementPolicyRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "scheduler", + "smt_awareness", + "smtAwareness", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Scheduler, + SmtAwareness, } - if let Some(v) = self.pid.as_ref() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("pid", ToString::to_string(&v).as_str())?; + 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 { + "scheduler" => Ok(GeneratedField::Scheduler), + "smtAwareness" | "smt_awareness" => Ok(GeneratedField::SmtAwareness), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if let Some(v) = self.ptid.as_ref() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("ptid", ToString::to_string(&v).as_str())?; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SetHostPowerManagementPolicyRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SetHostPowerManagementPolicyRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut scheduler__ = None; + let mut smt_awareness__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Scheduler => { + if scheduler__.is_some() { + return Err(serde::de::Error::duplicate_field("scheduler")); + } + scheduler__ = Some(map_.next_value()?); + } + GeneratedField::SmtAwareness => { + if smt_awareness__.is_some() { + return Err(serde::de::Error::duplicate_field("smtAwareness")); + } + smt_awareness__ = Some(map_.next_value()?); + } + } + } + Ok(SetHostPowerManagementPolicyRequest { + scheduler: scheduler__.unwrap_or_default(), + smt_awareness: smt_awareness__.unwrap_or_default(), + }) + } } - if self.sid != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("sid", ToString::to_string(&self.sid).as_str())?; - } - if self.vpgid != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("vpgid", ToString::to_string(&self.vpgid).as_str())?; + deserializer.deserialize_struct("protect.control.v1.SetHostPowerManagementPolicyRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SetZoneVcpuAffinityReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.SetZoneVcpuAffinityReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SetZoneVcpuAffinityReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { } - if self.pgid != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("pgid", ToString::to_string(&self.pgid).as_str())?; + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if !self.comm.is_empty() { - struct_ser.serialize_field("comm", &self.comm)?; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SetZoneVcpuAffinityReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SetZoneVcpuAffinityReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(SetZoneVcpuAffinityReply { + }) + } } - if !self.exe.is_empty() { - struct_ser.serialize_field("exe", &self.exe)?; + deserializer.deserialize_struct("protect.control.v1.SetZoneVcpuAffinityReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SetZoneVcpuAffinityRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; } - if !self.exepath.is_empty() { - struct_ser.serialize_field("exepath", &self.exepath)?; + if !self.vcpu.is_empty() { + len += 1; } - if self.exe_writable { - struct_ser.serialize_field("exeWritable", &self.exe_writable)?; + if !self.hard_affinity.is_empty() { + len += 1; } - if self.exe_upper_layer { - struct_ser.serialize_field("exeUpperLayer", &self.exe_upper_layer)?; + if !self.soft_affinity.is_empty() { + len += 1; } - if self.exe_lower_layer { - struct_ser.serialize_field("exeLowerLayer", &self.exe_lower_layer)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.SetZoneVcpuAffinityRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; } - if self.exe_from_memfd { - struct_ser.serialize_field("exeFromMemfd", &self.exe_from_memfd)?; + if !self.vcpu.is_empty() { + struct_ser.serialize_field("vcpu", &self.vcpu)?; } - if !self.args.is_empty() { - struct_ser.serialize_field("args", &self.args)?; + if !self.hard_affinity.is_empty() { + struct_ser.serialize_field("hardAffinity", &self.hard_affinity)?; } - if !self.env.is_empty() { - struct_ser.serialize_field("env", &self.env)?; + if !self.soft_affinity.is_empty() { + struct_ser.serialize_field("softAffinity", &self.soft_affinity)?; } - if !self.cwd.is_empty() { - struct_ser.serialize_field("cwd", &self.cwd)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SetZoneVcpuAffinityRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "vcpu", + "hard_affinity", + "hardAffinity", + "soft_affinity", + "softAffinity", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + Vcpu, + HardAffinity, + SoftAffinity, } - if self.fdlimit != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("fdlimit", ToString::to_string(&self.fdlimit).as_str())?; + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "vcpu" => Ok(GeneratedField::Vcpu), + "hardAffinity" | "hard_affinity" => Ok(GeneratedField::HardAffinity), + "softAffinity" | "soft_affinity" => Ok(GeneratedField::SoftAffinity), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if self.flags != 0 { - struct_ser.serialize_field("flags", &self.flags)?; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SetZoneVcpuAffinityRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SetZoneVcpuAffinityRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut vcpu__ = None; + let mut hard_affinity__ = None; + let mut soft_affinity__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Vcpu => { + if vcpu__.is_some() { + return Err(serde::de::Error::duplicate_field("vcpu")); + } + vcpu__ = Some(map_.next_value()?); + } + GeneratedField::HardAffinity => { + if hard_affinity__.is_some() { + return Err(serde::de::Error::duplicate_field("hardAffinity")); + } + hard_affinity__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + GeneratedField::SoftAffinity => { + if soft_affinity__.is_some() { + return Err(serde::de::Error::duplicate_field("softAffinity")); + } + soft_affinity__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(SetZoneVcpuAffinityRequest { + zone_id: zone_id__.unwrap_or_default(), + vcpu: vcpu__.unwrap_or_default(), + hard_affinity: hard_affinity__.unwrap_or_default(), + soft_affinity: soft_affinity__.unwrap_or_default(), + }) + } } - if self.uid != 0 { - struct_ser.serialize_field("uid", &self.uid)?; + deserializer.deserialize_struct("protect.control.v1.SetZoneVcpuAffinityRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SnoopControlPacket { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.id != 0 { + len += 1; } - if self.gid != 0 { - struct_ser.serialize_field("gid", &self.gid)?; + if self.origin.is_some() { + len += 1; } - if self.cap_permitted != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("capPermitted", ToString::to_string(&self.cap_permitted).as_str())?; + if !self.service.is_empty() { + len += 1; } - if self.cap_effective != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("capEffective", ToString::to_string(&self.cap_effective).as_str())?; + if !self.method.is_empty() { + len += 1; } - if self.cap_inheritable != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("capInheritable", ToString::to_string(&self.cap_inheritable).as_str())?; + if self.form != 0 { + len += 1; } - if self.exe_ino != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("exeIno", ToString::to_string(&self.exe_ino).as_str())?; + if !self.payload.is_empty() { + len += 1; } - if self.exe_ino_ctime != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("exeInoCtime", ToString::to_string(&self.exe_ino_ctime).as_str())?; + if self.closed { + len += 1; } - if self.exe_ino_mtime != 0 { + let mut struct_ser = serializer.serialize_struct("protect.control.v1.SnoopControlPacket", len)?; + if self.id != 0 { #[allow(clippy::needless_borrow)] #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("exeInoMtime", ToString::to_string(&self.exe_ino_mtime).as_str())?; + struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?; } - if self.exe_ino_ctime_duration_clone_ts != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("exeInoCtimeDurationCloneTs", ToString::to_string(&self.exe_ino_ctime_duration_clone_ts).as_str())?; + if let Some(v) = self.origin.as_ref() { + struct_ser.serialize_field("origin", v)?; } - if self.exe_ino_ctime_duration_pidns_start != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("exeInoCtimeDurationPidnsStart", ToString::to_string(&self.exe_ino_ctime_duration_pidns_start).as_str())?; + if !self.service.is_empty() { + struct_ser.serialize_field("service", &self.service)?; } - if self.vmsize_kb != 0 { - struct_ser.serialize_field("vmsizeKb", &self.vmsize_kb)?; + if !self.method.is_empty() { + struct_ser.serialize_field("method", &self.method)?; } - if self.vmrss_kb != 0 { - struct_ser.serialize_field("vmrssKb", &self.vmrss_kb)?; + if self.form != 0 { + let v = SnoopControlPacketForm::try_from(self.form) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.form)))?; + struct_ser.serialize_field("form", &v)?; } - if self.vmswap_kb != 0 { - struct_ser.serialize_field("vmswapKb", &self.vmswap_kb)?; + if !self.payload.is_empty() { + struct_ser.serialize_field("payload", &self.payload)?; } - if self.pfmajor != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("pfmajor", ToString::to_string(&self.pfmajor).as_str())?; - } - if self.pfminor != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("pfminor", ToString::to_string(&self.pfminor).as_str())?; - } - if let Some(v) = self.vtid.as_ref() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("vtid", ToString::to_string(&v).as_str())?; - } - if let Some(v) = self.vpid.as_ref() { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("vpid", ToString::to_string(&v).as_str())?; - } - if self.pidns_init_start_ts != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("pidnsInitStartTs", ToString::to_string(&self.pidns_init_start_ts).as_str())?; - } - if !self.cgroups.is_empty() { - struct_ser.serialize_field("cgroups", &self.cgroups)?; - } - if !self.root.is_empty() { - struct_ser.serialize_field("root", &self.root)?; - } - if self.filtered_out { - struct_ser.serialize_field("filteredOut", &self.filtered_out)?; - } - if !self.fdlist.is_empty() { - struct_ser.serialize_field("fdlist", &self.fdlist)?; - } - if self.clone_ts != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("cloneTs", ToString::to_string(&self.clone_ts).as_str())?; - } - if self.tty != 0 { - struct_ser.serialize_field("tty", &self.tty)?; - } - if self.loginuid != 0 { - struct_ser.serialize_field("loginuid", &self.loginuid)?; - } - if self.lastexec_ts != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("lastexecTs", ToString::to_string(&self.lastexec_ts).as_str())?; - } - if self.reaper { - struct_ser.serialize_field("reaper", &self.reaper)?; + if self.closed { + struct_ser.serialize_field("closed", &self.closed)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelThreadInfo { +impl<'de> serde::Deserialize<'de> for SnoopControlPacket { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "tid", - "pid", - "ptid", - "sid", - "vpgid", - "pgid", - "comm", - "exe", - "exepath", - "exe_writable", - "exeWritable", - "exe_upper_layer", - "exeUpperLayer", - "exe_lower_layer", - "exeLowerLayer", - "exe_from_memfd", - "exeFromMemfd", - "args", - "env", - "cwd", - "fdlimit", - "flags", - "uid", - "gid", - "cap_permitted", - "capPermitted", - "cap_effective", - "capEffective", - "cap_inheritable", - "capInheritable", - "exe_ino", - "exeIno", - "exe_ino_ctime", - "exeInoCtime", - "exe_ino_mtime", - "exeInoMtime", - "exe_ino_ctime_duration_clone_ts", - "exeInoCtimeDurationCloneTs", - "exe_ino_ctime_duration_pidns_start", - "exeInoCtimeDurationPidnsStart", - "vmsize_kb", - "vmsizeKb", - "vmrss_kb", - "vmrssKb", - "vmswap_kb", - "vmswapKb", - "pfmajor", - "pfminor", - "vtid", - "vpid", - "pidns_init_start_ts", - "pidnsInitStartTs", - "cgroups", - "root", - "filtered_out", - "filteredOut", - "fdlist", - "clone_ts", - "cloneTs", - "tty", - "loginuid", - "lastexec_ts", - "lastexecTs", - "reaper", + "id", + "origin", + "service", + "method", + "form", + "payload", + "closed", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Tid, - Pid, - Ptid, - Sid, - Vpgid, - Pgid, - Comm, - Exe, - Exepath, - ExeWritable, - ExeUpperLayer, - ExeLowerLayer, - ExeFromMemfd, - Args, - Env, - Cwd, - Fdlimit, - Flags, - Uid, - Gid, - CapPermitted, - CapEffective, - CapInheritable, - ExeIno, - ExeInoCtime, - ExeInoMtime, - ExeInoCtimeDurationCloneTs, - ExeInoCtimeDurationPidnsStart, - VmsizeKb, - VmrssKb, - VmswapKb, - Pfmajor, - Pfminor, - Vtid, - Vpid, - PidnsInitStartTs, - Cgroups, - Root, - FilteredOut, - Fdlist, - CloneTs, - Tty, - Loginuid, - LastexecTs, - Reaper, + Id, + Origin, + Service, + Method, + Form, + Payload, + Closed, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -17659,51 +18271,13 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelThreadInfo { E: serde::de::Error, { match value { - "tid" => Ok(GeneratedField::Tid), - "pid" => Ok(GeneratedField::Pid), - "ptid" => Ok(GeneratedField::Ptid), - "sid" => Ok(GeneratedField::Sid), - "vpgid" => Ok(GeneratedField::Vpgid), - "pgid" => Ok(GeneratedField::Pgid), - "comm" => Ok(GeneratedField::Comm), - "exe" => Ok(GeneratedField::Exe), - "exepath" => Ok(GeneratedField::Exepath), - "exeWritable" | "exe_writable" => Ok(GeneratedField::ExeWritable), - "exeUpperLayer" | "exe_upper_layer" => Ok(GeneratedField::ExeUpperLayer), - "exeLowerLayer" | "exe_lower_layer" => Ok(GeneratedField::ExeLowerLayer), - "exeFromMemfd" | "exe_from_memfd" => Ok(GeneratedField::ExeFromMemfd), - "args" => Ok(GeneratedField::Args), - "env" => Ok(GeneratedField::Env), - "cwd" => Ok(GeneratedField::Cwd), - "fdlimit" => Ok(GeneratedField::Fdlimit), - "flags" => Ok(GeneratedField::Flags), - "uid" => Ok(GeneratedField::Uid), - "gid" => Ok(GeneratedField::Gid), - "capPermitted" | "cap_permitted" => Ok(GeneratedField::CapPermitted), - "capEffective" | "cap_effective" => Ok(GeneratedField::CapEffective), - "capInheritable" | "cap_inheritable" => Ok(GeneratedField::CapInheritable), - "exeIno" | "exe_ino" => Ok(GeneratedField::ExeIno), - "exeInoCtime" | "exe_ino_ctime" => Ok(GeneratedField::ExeInoCtime), - "exeInoMtime" | "exe_ino_mtime" => Ok(GeneratedField::ExeInoMtime), - "exeInoCtimeDurationCloneTs" | "exe_ino_ctime_duration_clone_ts" => Ok(GeneratedField::ExeInoCtimeDurationCloneTs), - "exeInoCtimeDurationPidnsStart" | "exe_ino_ctime_duration_pidns_start" => Ok(GeneratedField::ExeInoCtimeDurationPidnsStart), - "vmsizeKb" | "vmsize_kb" => Ok(GeneratedField::VmsizeKb), - "vmrssKb" | "vmrss_kb" => Ok(GeneratedField::VmrssKb), - "vmswapKb" | "vmswap_kb" => Ok(GeneratedField::VmswapKb), - "pfmajor" => Ok(GeneratedField::Pfmajor), - "pfminor" => Ok(GeneratedField::Pfminor), - "vtid" => Ok(GeneratedField::Vtid), - "vpid" => Ok(GeneratedField::Vpid), - "pidnsInitStartTs" | "pidns_init_start_ts" => Ok(GeneratedField::PidnsInitStartTs), - "cgroups" => Ok(GeneratedField::Cgroups), - "root" => Ok(GeneratedField::Root), - "filteredOut" | "filtered_out" => Ok(GeneratedField::FilteredOut), - "fdlist" => Ok(GeneratedField::Fdlist), - "cloneTs" | "clone_ts" => Ok(GeneratedField::CloneTs), - "tty" => Ok(GeneratedField::Tty), - "loginuid" => Ok(GeneratedField::Loginuid), - "lastexecTs" | "lastexec_ts" => Ok(GeneratedField::LastexecTs), - "reaper" => Ok(GeneratedField::Reaper), + "id" => Ok(GeneratedField::Id), + "origin" => Ok(GeneratedField::Origin), + "service" => Ok(GeneratedField::Service), + "method" => Ok(GeneratedField::Method), + "form" => Ok(GeneratedField::Form), + "payload" => Ok(GeneratedField::Payload), + "closed" => Ok(GeneratedField::Closed), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -17713,166 +18287,10945 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelThreadInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelThreadInfo; + type Value = SnoopControlPacket; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelThreadInfo") + formatter.write_str("struct protect.control.v1.SnoopControlPacket") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut tid__ = None; - let mut pid__ = None; - let mut ptid__ = None; - let mut sid__ = None; - let mut vpgid__ = None; - let mut pgid__ = None; - let mut comm__ = None; - let mut exe__ = None; - let mut exepath__ = None; - let mut exe_writable__ = None; - let mut exe_upper_layer__ = None; - let mut exe_lower_layer__ = None; - let mut exe_from_memfd__ = None; - let mut args__ = None; - let mut env__ = None; - let mut cwd__ = None; - let mut fdlimit__ = None; - let mut flags__ = None; - let mut uid__ = None; - let mut gid__ = None; - let mut cap_permitted__ = None; - let mut cap_effective__ = None; - let mut cap_inheritable__ = None; - let mut exe_ino__ = None; - let mut exe_ino_ctime__ = None; - let mut exe_ino_mtime__ = None; - let mut exe_ino_ctime_duration_clone_ts__ = None; - let mut exe_ino_ctime_duration_pidns_start__ = None; - let mut vmsize_kb__ = None; - let mut vmrss_kb__ = None; - let mut vmswap_kb__ = None; - let mut pfmajor__ = None; - let mut pfminor__ = None; - let mut vtid__ = None; - let mut vpid__ = None; - let mut pidns_init_start_ts__ = None; - let mut cgroups__ = None; - let mut root__ = None; - let mut filtered_out__ = None; - let mut fdlist__ = None; - let mut clone_ts__ = None; - let mut tty__ = None; - let mut loginuid__ = None; - let mut lastexec_ts__ = None; - let mut reaper__ = None; + let mut id__ = None; + let mut origin__ = None; + let mut service__ = None; + let mut method__ = None; + let mut form__ = None; + let mut payload__ = None; + let mut closed__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Tid => { - if tid__.is_some() { - return Err(serde::de::Error::duplicate_field("tid")); - } - tid__ = - map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) - ; - } - GeneratedField::Pid => { - if pid__.is_some() { - return Err(serde::de::Error::duplicate_field("pid")); - } - pid__ = - map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) - ; - } - GeneratedField::Ptid => { - if ptid__.is_some() { - return Err(serde::de::Error::duplicate_field("ptid")); - } - ptid__ = - map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) - ; - } - GeneratedField::Sid => { - if sid__.is_some() { - return Err(serde::de::Error::duplicate_field("sid")); - } - sid__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Vpgid => { - if vpgid__.is_some() { - return Err(serde::de::Error::duplicate_field("vpgid")); - } - vpgid__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Pgid => { - if pgid__.is_some() { - return Err(serde::de::Error::duplicate_field("pgid")); + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); } - pgid__ = + id__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Comm => { - if comm__.is_some() { - return Err(serde::de::Error::duplicate_field("comm")); + GeneratedField::Origin => { + if origin__.is_some() { + return Err(serde::de::Error::duplicate_field("origin")); } - comm__ = Some(map_.next_value()?); + origin__ = map_.next_value()?; } - GeneratedField::Exe => { - if exe__.is_some() { - return Err(serde::de::Error::duplicate_field("exe")); + GeneratedField::Service => { + if service__.is_some() { + return Err(serde::de::Error::duplicate_field("service")); } - exe__ = Some(map_.next_value()?); + service__ = Some(map_.next_value()?); } - GeneratedField::Exepath => { - if exepath__.is_some() { - return Err(serde::de::Error::duplicate_field("exepath")); + GeneratedField::Method => { + if method__.is_some() { + return Err(serde::de::Error::duplicate_field("method")); } - exepath__ = Some(map_.next_value()?); + method__ = Some(map_.next_value()?); } - GeneratedField::ExeWritable => { - if exe_writable__.is_some() { - return Err(serde::de::Error::duplicate_field("exeWritable")); + GeneratedField::Form => { + if form__.is_some() { + return Err(serde::de::Error::duplicate_field("form")); } - exe_writable__ = Some(map_.next_value()?); + form__ = Some(map_.next_value::()? as i32); } - GeneratedField::ExeUpperLayer => { - if exe_upper_layer__.is_some() { - return Err(serde::de::Error::duplicate_field("exeUpperLayer")); + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); } - exe_upper_layer__ = Some(map_.next_value()?); + payload__ = Some(map_.next_value()?); } - GeneratedField::ExeLowerLayer => { - if exe_lower_layer__.is_some() { - return Err(serde::de::Error::duplicate_field("exeLowerLayer")); + GeneratedField::Closed => { + if closed__.is_some() { + return Err(serde::de::Error::duplicate_field("closed")); } - exe_lower_layer__ = Some(map_.next_value()?); + closed__ = Some(map_.next_value()?); } - GeneratedField::ExeFromMemfd => { - if exe_from_memfd__.is_some() { - return Err(serde::de::Error::duplicate_field("exeFromMemfd")); - } - exe_from_memfd__ = Some(map_.next_value()?); + } + } + Ok(SnoopControlPacket { + id: id__.unwrap_or_default(), + origin: origin__, + service: service__.unwrap_or_default(), + method: method__.unwrap_or_default(), + form: form__.unwrap_or_default(), + payload: payload__.unwrap_or_default(), + closed: closed__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.SnoopControlPacket", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SnoopControlPacketForm { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "SNOOP_CONTROL_PACKET_FORM_UNKNOWN", + Self::Request => "SNOOP_CONTROL_PACKET_FORM_REQUEST", + Self::Error => "SNOOP_CONTROL_PACKET_FORM_ERROR", + Self::Response => "SNOOP_CONTROL_PACKET_FORM_RESPONSE", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for SnoopControlPacketForm { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "SNOOP_CONTROL_PACKET_FORM_UNKNOWN", + "SNOOP_CONTROL_PACKET_FORM_REQUEST", + "SNOOP_CONTROL_PACKET_FORM_ERROR", + "SNOOP_CONTROL_PACKET_FORM_RESPONSE", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SnoopControlPacketForm; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "SNOOP_CONTROL_PACKET_FORM_UNKNOWN" => Ok(SnoopControlPacketForm::Unknown), + "SNOOP_CONTROL_PACKET_FORM_REQUEST" => Ok(SnoopControlPacketForm::Request), + "SNOOP_CONTROL_PACKET_FORM_ERROR" => Ok(SnoopControlPacketForm::Error), + "SNOOP_CONTROL_PACKET_FORM_RESPONSE" => Ok(SnoopControlPacketForm::Response), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for SnoopControlReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.packets.is_empty() { + len += 1; + } + if self.skipped != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.SnoopControlReply", len)?; + if !self.packets.is_empty() { + struct_ser.serialize_field("packets", &self.packets)?; + } + if self.skipped != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("skipped", ToString::to_string(&self.skipped).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SnoopControlReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "packets", + "skipped", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Packets, + Skipped, + } + 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 { + "packets" => Ok(GeneratedField::Packets), + "skipped" => Ok(GeneratedField::Skipped), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } - GeneratedField::Args => { - if args__.is_some() { - return Err(serde::de::Error::duplicate_field("args")); + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SnoopControlReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SnoopControlReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut packets__ = None; + let mut skipped__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Packets => { + if packets__.is_some() { + return Err(serde::de::Error::duplicate_field("packets")); } - args__ = Some(map_.next_value()?); + packets__ = Some(map_.next_value()?); } - GeneratedField::Env => { - if env__.is_some() { - return Err(serde::de::Error::duplicate_field("env")); + GeneratedField::Skipped => { + if skipped__.is_some() { + return Err(serde::de::Error::duplicate_field("skipped")); } - env__ = Some(map_.next_value()?); + skipped__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Cwd => { + } + } + Ok(SnoopControlReply { + packets: packets__.unwrap_or_default(), + skipped: skipped__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.SnoopControlReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SnoopControlRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.SnoopControlRequest", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SnoopControlRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SnoopControlRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SnoopControlRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(SnoopControlRequest { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.SnoopControlRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SnoopIdmPacket { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.from.is_empty() { + len += 1; + } + if !self.to.is_empty() { + len += 1; + } + if !self.packet.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.SnoopIdmPacket", len)?; + if !self.from.is_empty() { + struct_ser.serialize_field("from", &self.from)?; + } + if !self.to.is_empty() { + struct_ser.serialize_field("to", &self.to)?; + } + if !self.packet.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("packet", pbjson::private::base64::encode(&self.packet).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SnoopIdmPacket { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "from", + "to", + "packet", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + From, + To, + Packet, + } + 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 { + "from" => Ok(GeneratedField::From), + "to" => Ok(GeneratedField::To), + "packet" => Ok(GeneratedField::Packet), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SnoopIdmPacket; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SnoopIdmPacket") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut from__ = None; + let mut to__ = None; + let mut packet__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::From => { + if from__.is_some() { + return Err(serde::de::Error::duplicate_field("from")); + } + from__ = Some(map_.next_value()?); + } + GeneratedField::To => { + if to__.is_some() { + return Err(serde::de::Error::duplicate_field("to")); + } + to__ = Some(map_.next_value()?); + } + GeneratedField::Packet => { + if packet__.is_some() { + return Err(serde::de::Error::duplicate_field("packet")); + } + packet__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(SnoopIdmPacket { + from: from__.unwrap_or_default(), + to: to__.unwrap_or_default(), + packet: packet__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.SnoopIdmPacket", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SnoopIdmReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.packets.is_empty() { + len += 1; + } + if self.skipped != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.SnoopIdmReply", len)?; + if !self.packets.is_empty() { + struct_ser.serialize_field("packets", &self.packets)?; + } + if self.skipped != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("skipped", ToString::to_string(&self.skipped).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SnoopIdmReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "packets", + "skipped", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Packets, + Skipped, + } + 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 { + "packets" => Ok(GeneratedField::Packets), + "skipped" => Ok(GeneratedField::Skipped), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SnoopIdmReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SnoopIdmReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut packets__ = None; + let mut skipped__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Packets => { + if packets__.is_some() { + return Err(serde::de::Error::duplicate_field("packets")); + } + packets__ = Some(map_.next_value()?); + } + GeneratedField::Skipped => { + if skipped__.is_some() { + return Err(serde::de::Error::duplicate_field("skipped")); + } + skipped__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(SnoopIdmReply { + packets: packets__.unwrap_or_default(), + skipped: skipped__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.SnoopIdmReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SnoopIdmRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.SnoopIdmRequest", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SnoopIdmRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SnoopIdmRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SnoopIdmRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(SnoopIdmRequest { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.SnoopIdmRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for StartRestoredZoneReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.StartRestoredZoneReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for StartRestoredZoneReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = StartRestoredZoneReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.StartRestoredZoneReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(StartRestoredZoneReply { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.StartRestoredZoneReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for StartRestoredZoneRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if !self.bindings.is_empty() { + len += 1; + } + if !self.annotations.is_empty() { + len += 1; + } + if !self.dropped_workload_ids.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.StartRestoredZoneRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.bindings.is_empty() { + struct_ser.serialize_field("bindings", &self.bindings)?; + } + if !self.annotations.is_empty() { + struct_ser.serialize_field("annotations", &self.annotations)?; + } + if !self.dropped_workload_ids.is_empty() { + struct_ser.serialize_field("droppedWorkloadIds", &self.dropped_workload_ids)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for StartRestoredZoneRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "bindings", + "annotations", + "dropped_workload_ids", + "droppedWorkloadIds", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + Bindings, + Annotations, + DroppedWorkloadIds, + } + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "bindings" => Ok(GeneratedField::Bindings), + "annotations" => Ok(GeneratedField::Annotations), + "droppedWorkloadIds" | "dropped_workload_ids" => Ok(GeneratedField::DroppedWorkloadIds), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = StartRestoredZoneRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.StartRestoredZoneRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut bindings__ = None; + let mut annotations__ = None; + let mut dropped_workload_ids__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Bindings => { + if bindings__.is_some() { + return Err(serde::de::Error::duplicate_field("bindings")); + } + bindings__ = Some(map_.next_value()?); + } + GeneratedField::Annotations => { + if annotations__.is_some() { + return Err(serde::de::Error::duplicate_field("annotations")); + } + annotations__ = Some(map_.next_value()?); + } + GeneratedField::DroppedWorkloadIds => { + if dropped_workload_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("droppedWorkloadIds")); + } + dropped_workload_ids__ = Some(map_.next_value()?); + } + } + } + Ok(StartRestoredZoneRequest { + zone_id: zone_id__.unwrap_or_default(), + bindings: bindings__.unwrap_or_default(), + annotations: annotations__.unwrap_or_default(), + dropped_workload_ids: dropped_workload_ids__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.StartRestoredZoneRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for StartWorkloadReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.StartWorkloadReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for StartWorkloadReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = StartWorkloadReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.StartWorkloadReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(StartWorkloadReply { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.StartWorkloadReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for StartWorkloadRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.workload_id.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.StartWorkloadRequest", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for StartWorkloadRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "workload_id", + "workloadId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WorkloadId, + } + 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 { + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = StartWorkloadRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.StartWorkloadRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut workload_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); + } + workload_id__ = Some(map_.next_value()?); + } + } + } + Ok(StartWorkloadRequest { + workload_id: workload_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.StartWorkloadRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for StopWorkloadReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.StopWorkloadReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for StopWorkloadReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = StopWorkloadReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.StopWorkloadReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(StopWorkloadReply { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.StopWorkloadReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for StopWorkloadRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.workload_id.is_empty() { + len += 1; + } + if self.timeout != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.StopWorkloadRequest", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; + } + if self.timeout != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("timeout", ToString::to_string(&self.timeout).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for StopWorkloadRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "workload_id", + "workloadId", + "timeout", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WorkloadId, + Timeout, + } + 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 { + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "timeout" => Ok(GeneratedField::Timeout), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = StopWorkloadRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.StopWorkloadRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut workload_id__ = None; + let mut timeout__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); + } + workload_id__ = Some(map_.next_value()?); + } + GeneratedField::Timeout => { + if timeout__.is_some() { + return Err(serde::de::Error::duplicate_field("timeout")); + } + timeout__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(StopWorkloadRequest { + workload_id: workload_id__.unwrap_or_default(), + timeout: timeout__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.StopWorkloadRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SuspendZoneReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.SuspendZoneReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SuspendZoneReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SuspendZoneReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SuspendZoneReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(SuspendZoneReply { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.SuspendZoneReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SuspendZoneRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.SuspendZoneRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SuspendZoneRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + } + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SuspendZoneRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.SuspendZoneRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + } + } + Ok(SuspendZoneRequest { + zone_id: zone_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.SuspendZoneRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TerminalSize { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.rows != 0 { + len += 1; + } + if self.columns != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.TerminalSize", len)?; + if self.rows != 0 { + struct_ser.serialize_field("rows", &self.rows)?; + } + if self.columns != 0 { + struct_ser.serialize_field("columns", &self.columns)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TerminalSize { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "rows", + "columns", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Rows, + Columns, + } + 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 { + "rows" => Ok(GeneratedField::Rows), + "columns" => Ok(GeneratedField::Columns), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TerminalSize; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.TerminalSize") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut rows__ = None; + let mut columns__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Rows => { + if rows__.is_some() { + return Err(serde::de::Error::duplicate_field("rows")); + } + rows__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Columns => { + if columns__.is_some() { + return Err(serde::de::Error::duplicate_field("columns")); + } + columns__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(TerminalSize { + rows: rows__.unwrap_or_default(), + columns: columns__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.TerminalSize", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UnadvertiseServiceEvent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.uuid.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.UnadvertiseServiceEvent", len)?; + if !self.uuid.is_empty() { + struct_ser.serialize_field("uuid", &self.uuid)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UnadvertiseServiceEvent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "uuid", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Uuid, + } + 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 { + "uuid" => Ok(GeneratedField::Uuid), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UnadvertiseServiceEvent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.UnadvertiseServiceEvent") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut uuid__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Uuid => { + if uuid__.is_some() { + return Err(serde::de::Error::duplicate_field("uuid")); + } + uuid__ = Some(map_.next_value()?); + } + } + } + Ok(UnadvertiseServiceEvent { + uuid: uuid__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.UnadvertiseServiceEvent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UnadvertiseZoneServiceReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.UnadvertiseZoneServiceReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UnadvertiseZoneServiceReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UnadvertiseZoneServiceReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.UnadvertiseZoneServiceReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(UnadvertiseZoneServiceReply { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.UnadvertiseZoneServiceReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UnadvertiseZoneServiceRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.config.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.UnadvertiseZoneServiceRequest", len)?; + if let Some(v) = self.config.as_ref() { + struct_ser.serialize_field("config", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UnadvertiseZoneServiceRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "config", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Config, + } + 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 { + "config" => Ok(GeneratedField::Config), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UnadvertiseZoneServiceRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.UnadvertiseZoneServiceRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut config__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Config => { + if config__.is_some() { + return Err(serde::de::Error::duplicate_field("config")); + } + config__ = map_.next_value()?; + } + } + } + Ok(UnadvertiseZoneServiceRequest { + config: config__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.UnadvertiseZoneServiceRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UpdateWorkloadResourcesReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.UpdateWorkloadResourcesReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UpdateWorkloadResourcesReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UpdateWorkloadResourcesReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.UpdateWorkloadResourcesReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(UpdateWorkloadResourcesReply { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.UpdateWorkloadResourcesReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UpdateWorkloadResourcesRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.workload_id.is_empty() { + len += 1; + } + if !self.cgroup_limits.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.UpdateWorkloadResourcesRequest", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; + } + if !self.cgroup_limits.is_empty() { + struct_ser.serialize_field("cgroupLimits", &self.cgroup_limits)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UpdateWorkloadResourcesRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "workload_id", + "workloadId", + "cgroup_limits", + "cgroupLimits", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WorkloadId, + CgroupLimits, + } + 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 { + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "cgroupLimits" | "cgroup_limits" => Ok(GeneratedField::CgroupLimits), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UpdateWorkloadResourcesRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.UpdateWorkloadResourcesRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut workload_id__ = None; + let mut cgroup_limits__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); + } + workload_id__ = Some(map_.next_value()?); + } + GeneratedField::CgroupLimits => { + if cgroup_limits__.is_some() { + return Err(serde::de::Error::duplicate_field("cgroupLimits")); + } + cgroup_limits__ = Some(map_.next_value()?); + } + } + } + Ok(UpdateWorkloadResourcesRequest { + workload_id: workload_id__.unwrap_or_default(), + cgroup_limits: cgroup_limits__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.UpdateWorkloadResourcesRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UpdateZoneResourcesReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.UpdateZoneResourcesReply", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UpdateZoneResourcesReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UpdateZoneResourcesReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.UpdateZoneResourcesReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(UpdateZoneResourcesReply { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.UpdateZoneResourcesReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UpdateZoneResourcesRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if self.resources.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.UpdateZoneResourcesRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if let Some(v) = self.resources.as_ref() { + struct_ser.serialize_field("resources", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UpdateZoneResourcesRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "resources", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + Resources, + } + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "resources" => Ok(GeneratedField::Resources), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UpdateZoneResourcesRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.UpdateZoneResourcesRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut resources__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Resources => { + if resources__.is_some() { + return Err(serde::de::Error::duplicate_field("resources")); + } + resources__ = map_.next_value()?; + } + } + } + Ok(UpdateZoneResourcesRequest { + zone_id: zone_id__.unwrap_or_default(), + resources: resources__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.UpdateZoneResourcesRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for VcpuAffinitiesSpec { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.vcpu.is_some() { + len += 1; + } + if !self.hard_affinity.is_empty() { + len += 1; + } + if !self.soft_affinity.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.VcpuAffinitiesSpec", len)?; + if let Some(v) = self.vcpu.as_ref() { + struct_ser.serialize_field("vcpu", v)?; + } + if !self.hard_affinity.is_empty() { + struct_ser.serialize_field("hardAffinity", &self.hard_affinity)?; + } + if !self.soft_affinity.is_empty() { + struct_ser.serialize_field("softAffinity", &self.soft_affinity)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for VcpuAffinitiesSpec { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "vcpu", + "hard_affinity", + "hardAffinity", + "soft_affinity", + "softAffinity", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Vcpu, + HardAffinity, + SoftAffinity, + } + 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 { + "vcpu" => Ok(GeneratedField::Vcpu), + "hardAffinity" | "hard_affinity" => Ok(GeneratedField::HardAffinity), + "softAffinity" | "soft_affinity" => Ok(GeneratedField::SoftAffinity), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = VcpuAffinitiesSpec; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.VcpuAffinitiesSpec") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut vcpu__ = None; + let mut hard_affinity__ = None; + let mut soft_affinity__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Vcpu => { + if vcpu__.is_some() { + return Err(serde::de::Error::duplicate_field("vcpu")); + } + vcpu__ = map_.next_value()?; + } + GeneratedField::HardAffinity => { + if hard_affinity__.is_some() { + return Err(serde::de::Error::duplicate_field("hardAffinity")); + } + hard_affinity__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + GeneratedField::SoftAffinity => { + if soft_affinity__.is_some() { + return Err(serde::de::Error::duplicate_field("softAffinity")); + } + soft_affinity__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(VcpuAffinitiesSpec { + vcpu: vcpu__, + hard_affinity: hard_affinity__.unwrap_or_default(), + soft_affinity: soft_affinity__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.VcpuAffinitiesSpec", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for VcpuAffinitiesSpecSet { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.entries.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.VcpuAffinitiesSpecSet", len)?; + if !self.entries.is_empty() { + struct_ser.serialize_field("entries", &self.entries)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for VcpuAffinitiesSpecSet { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "entries", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Entries, + } + 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 { + "entries" => Ok(GeneratedField::Entries), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = VcpuAffinitiesSpecSet; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.VcpuAffinitiesSpecSet") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut entries__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Entries => { + if entries__.is_some() { + return Err(serde::de::Error::duplicate_field("entries")); + } + entries__ = Some(map_.next_value()?); + } + } + } + Ok(VcpuAffinitiesSpecSet { + entries: entries__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.VcpuAffinitiesSpecSet", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for VcpuIdSpecifier { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.index.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.VcpuIdSpecifier", len)?; + if let Some(v) = self.index.as_ref() { + match v { + vcpu_id_specifier::Index::AllVcpus(v) => { + struct_ser.serialize_field("allVcpus", v)?; + } + vcpu_id_specifier::Index::Value(v) => { + struct_ser.serialize_field("value", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for VcpuIdSpecifier { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "all_vcpus", + "allVcpus", + "value", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + AllVcpus, + Value, + } + 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 { + "allVcpus" | "all_vcpus" => Ok(GeneratedField::AllVcpus), + "value" => Ok(GeneratedField::Value), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = VcpuIdSpecifier; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.VcpuIdSpecifier") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut index__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::AllVcpus => { + if index__.is_some() { + return Err(serde::de::Error::duplicate_field("allVcpus")); + } + index__ = map_.next_value::<::std::option::Option<_>>()?.map(vcpu_id_specifier::Index::AllVcpus) +; + } + GeneratedField::Value => { + if index__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + index__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| vcpu_id_specifier::Index::Value(x.0)); + } + } + } + Ok(VcpuIdSpecifier { + index: index__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.VcpuIdSpecifier", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for VcpuInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.vcpu != 0 { + len += 1; + } + if self.online { + len += 1; + } + if self.blocked { + len += 1; + } + if self.running { + len += 1; + } + if self.cpu_time != 0 { + len += 1; + } + if self.cpu != 0 { + len += 1; + } + if !self.hard_affinity.is_empty() { + len += 1; + } + if !self.soft_affinity.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.VcpuInfo", len)?; + if self.vcpu != 0 { + struct_ser.serialize_field("vcpu", &self.vcpu)?; + } + if self.online { + struct_ser.serialize_field("online", &self.online)?; + } + if self.blocked { + struct_ser.serialize_field("blocked", &self.blocked)?; + } + if self.running { + struct_ser.serialize_field("running", &self.running)?; + } + if self.cpu_time != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("cpuTime", ToString::to_string(&self.cpu_time).as_str())?; + } + if self.cpu != 0 { + struct_ser.serialize_field("cpu", &self.cpu)?; + } + if !self.hard_affinity.is_empty() { + struct_ser.serialize_field("hardAffinity", &self.hard_affinity)?; + } + if !self.soft_affinity.is_empty() { + struct_ser.serialize_field("softAffinity", &self.soft_affinity)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for VcpuInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "vcpu", + "online", + "blocked", + "running", + "cpu_time", + "cpuTime", + "cpu", + "hard_affinity", + "hardAffinity", + "soft_affinity", + "softAffinity", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Vcpu, + Online, + Blocked, + Running, + CpuTime, + Cpu, + HardAffinity, + SoftAffinity, + } + 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 { + "vcpu" => Ok(GeneratedField::Vcpu), + "online" => Ok(GeneratedField::Online), + "blocked" => Ok(GeneratedField::Blocked), + "running" => Ok(GeneratedField::Running), + "cpuTime" | "cpu_time" => Ok(GeneratedField::CpuTime), + "cpu" => Ok(GeneratedField::Cpu), + "hardAffinity" | "hard_affinity" => Ok(GeneratedField::HardAffinity), + "softAffinity" | "soft_affinity" => Ok(GeneratedField::SoftAffinity), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = VcpuInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.VcpuInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut vcpu__ = None; + let mut online__ = None; + let mut blocked__ = None; + let mut running__ = None; + let mut cpu_time__ = None; + let mut cpu__ = None; + let mut hard_affinity__ = None; + let mut soft_affinity__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Vcpu => { + if vcpu__.is_some() { + return Err(serde::de::Error::duplicate_field("vcpu")); + } + vcpu__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Online => { + if online__.is_some() { + return Err(serde::de::Error::duplicate_field("online")); + } + online__ = Some(map_.next_value()?); + } + GeneratedField::Blocked => { + if blocked__.is_some() { + return Err(serde::de::Error::duplicate_field("blocked")); + } + blocked__ = Some(map_.next_value()?); + } + GeneratedField::Running => { + if running__.is_some() { + return Err(serde::de::Error::duplicate_field("running")); + } + running__ = Some(map_.next_value()?); + } + GeneratedField::CpuTime => { + if cpu_time__.is_some() { + return Err(serde::de::Error::duplicate_field("cpuTime")); + } + cpu_time__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Cpu => { + if cpu__.is_some() { + return Err(serde::de::Error::duplicate_field("cpu")); + } + cpu__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::HardAffinity => { + if hard_affinity__.is_some() { + return Err(serde::de::Error::duplicate_field("hardAffinity")); + } + hard_affinity__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + GeneratedField::SoftAffinity => { + if soft_affinity__.is_some() { + return Err(serde::de::Error::duplicate_field("softAffinity")); + } + soft_affinity__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(VcpuInfo { + vcpu: vcpu__.unwrap_or_default(), + online: online__.unwrap_or_default(), + blocked: blocked__.unwrap_or_default(), + running: running__.unwrap_or_default(), + cpu_time: cpu_time__.unwrap_or_default(), + cpu: cpu__.unwrap_or_default(), + hard_affinity: hard_affinity__.unwrap_or_default(), + soft_affinity: soft_affinity__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.VcpuInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for VcpuInfoSet { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if !self.vcpus.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.VcpuInfoSet", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.vcpus.is_empty() { + struct_ser.serialize_field("vcpus", &self.vcpus)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for VcpuInfoSet { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "vcpus", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + Vcpus, + } + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "vcpus" => Ok(GeneratedField::Vcpus), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = VcpuInfoSet; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.VcpuInfoSet") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut vcpus__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Vcpus => { + if vcpus__.is_some() { + return Err(serde::de::Error::duplicate_field("vcpus")); + } + vcpus__ = Some(map_.next_value()?); + } + } + } + Ok(VcpuInfoSet { + zone_id: zone_id__.unwrap_or_default(), + vcpus: vcpus__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.VcpuInfoSet", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WatchEventsReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.event.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WatchEventsReply", len)?; + if let Some(v) = self.event.as_ref() { + match v { + watch_events_reply::Event::ZoneChanged(v) => { + struct_ser.serialize_field("zoneChanged", v)?; + } + watch_events_reply::Event::WorkloadChanged(v) => { + struct_ser.serialize_field("workloadChanged", v)?; + } + watch_events_reply::Event::AdvertiseService(v) => { + struct_ser.serialize_field("advertiseService", v)?; + } + watch_events_reply::Event::UnadvertiseService(v) => { + struct_ser.serialize_field("unadvertiseService", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WatchEventsReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_changed", + "zoneChanged", + "workload_changed", + "workloadChanged", + "advertise_service", + "advertiseService", + "unadvertise_service", + "unadvertiseService", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneChanged, + WorkloadChanged, + AdvertiseService, + UnadvertiseService, + } + 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 { + "zoneChanged" | "zone_changed" => Ok(GeneratedField::ZoneChanged), + "workloadChanged" | "workload_changed" => Ok(GeneratedField::WorkloadChanged), + "advertiseService" | "advertise_service" => Ok(GeneratedField::AdvertiseService), + "unadvertiseService" | "unadvertise_service" => Ok(GeneratedField::UnadvertiseService), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WatchEventsReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WatchEventsReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut event__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneChanged => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneChanged")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_events_reply::Event::ZoneChanged) +; + } + GeneratedField::WorkloadChanged => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadChanged")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_events_reply::Event::WorkloadChanged) +; + } + GeneratedField::AdvertiseService => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("advertiseService")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_events_reply::Event::AdvertiseService) +; + } + GeneratedField::UnadvertiseService => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("unadvertiseService")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_events_reply::Event::UnadvertiseService) +; + } + } + } + Ok(WatchEventsReply { + event: event__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WatchEventsReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WatchEventsRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.WatchEventsRequest", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WatchEventsRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WatchEventsRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WatchEventsRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(WatchEventsRequest { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WatchEventsRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Workload { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if self.spec.is_some() { + len += 1; + } + if self.status.is_some() { + len += 1; + } + if self.origin.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.Workload", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if let Some(v) = self.spec.as_ref() { + struct_ser.serialize_field("spec", v)?; + } + if let Some(v) = self.status.as_ref() { + struct_ser.serialize_field("status", v)?; + } + if let Some(v) = self.origin.as_ref() { + struct_ser.serialize_field("origin", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Workload { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "spec", + "status", + "origin", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + Spec, + Status, + Origin, + } + 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 { + "id" => Ok(GeneratedField::Id), + "spec" => Ok(GeneratedField::Spec), + "status" => Ok(GeneratedField::Status), + "origin" => Ok(GeneratedField::Origin), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Workload; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.Workload") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut spec__ = None; + let mut status__ = None; + let mut origin__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::Spec => { + if spec__.is_some() { + return Err(serde::de::Error::duplicate_field("spec")); + } + spec__ = map_.next_value()?; + } + GeneratedField::Status => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("status")); + } + status__ = map_.next_value()?; + } + GeneratedField::Origin => { + if origin__.is_some() { + return Err(serde::de::Error::duplicate_field("origin")); + } + origin__ = map_.next_value()?; + } + } + } + Ok(Workload { + id: id__.unwrap_or_default(), + spec: spec__, + status: status__, + origin: origin__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.Workload", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadBlockDeviceInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.block_index != 0 { + len += 1; + } + if self.device_id != 0 { + len += 1; + } + if !self.device.is_empty() { + len += 1; + } + if self.loop_dev { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadBlockDeviceInfo", len)?; + if self.block_index != 0 { + struct_ser.serialize_field("blockIndex", &self.block_index)?; + } + if self.device_id != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("deviceId", ToString::to_string(&self.device_id).as_str())?; + } + if !self.device.is_empty() { + struct_ser.serialize_field("device", &self.device)?; + } + if self.loop_dev { + struct_ser.serialize_field("loopDev", &self.loop_dev)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "block_index", + "blockIndex", + "device_id", + "deviceId", + "device", + "loop_dev", + "loopDev", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + BlockIndex, + DeviceId, + Device, + LoopDev, + } + 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 { + "blockIndex" | "block_index" => Ok(GeneratedField::BlockIndex), + "deviceId" | "device_id" => Ok(GeneratedField::DeviceId), + "device" => Ok(GeneratedField::Device), + "loopDev" | "loop_dev" => Ok(GeneratedField::LoopDev), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadBlockDeviceInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadBlockDeviceInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut block_index__ = None; + let mut device_id__ = None; + let mut device__ = None; + let mut loop_dev__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::BlockIndex => { + if block_index__.is_some() { + return Err(serde::de::Error::duplicate_field("blockIndex")); + } + block_index__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::DeviceId => { + if device_id__.is_some() { + return Err(serde::de::Error::duplicate_field("deviceId")); + } + device_id__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Device => { + if device__.is_some() { + return Err(serde::de::Error::duplicate_field("device")); + } + device__ = Some(map_.next_value()?); + } + GeneratedField::LoopDev => { + if loop_dev__.is_some() { + return Err(serde::de::Error::duplicate_field("loopDev")); + } + loop_dev__ = Some(map_.next_value()?); + } + } + } + Ok(WorkloadBlockDeviceInfo { + block_index: block_index__.unwrap_or_default(), + device_id: device_id__.unwrap_or_default(), + device: device__.unwrap_or_default(), + loop_dev: loop_dev__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadBlockDeviceInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadBlockDeviceSpec { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.target_path.is_empty() { + len += 1; + } + if !self.device_path.is_empty() { + len += 1; + } + if self.mount_options.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadBlockDeviceSpec", len)?; + if !self.target_path.is_empty() { + struct_ser.serialize_field("targetPath", &self.target_path)?; + } + if !self.device_path.is_empty() { + struct_ser.serialize_field("devicePath", &self.device_path)?; + } + if let Some(v) = self.mount_options.as_ref() { + struct_ser.serialize_field("mountOptions", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceSpec { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "target_path", + "targetPath", + "device_path", + "devicePath", + "mount_options", + "mountOptions", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TargetPath, + DevicePath, + MountOptions, + } + 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 { + "targetPath" | "target_path" => Ok(GeneratedField::TargetPath), + "devicePath" | "device_path" => Ok(GeneratedField::DevicePath), + "mountOptions" | "mount_options" => Ok(GeneratedField::MountOptions), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadBlockDeviceSpec; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadBlockDeviceSpec") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut target_path__ = None; + let mut device_path__ = None; + let mut mount_options__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::TargetPath => { + if target_path__.is_some() { + return Err(serde::de::Error::duplicate_field("targetPath")); + } + target_path__ = Some(map_.next_value()?); + } + GeneratedField::DevicePath => { + if device_path__.is_some() { + return Err(serde::de::Error::duplicate_field("devicePath")); + } + device_path__ = Some(map_.next_value()?); + } + GeneratedField::MountOptions => { + if mount_options__.is_some() { + return Err(serde::de::Error::duplicate_field("mountOptions")); + } + mount_options__ = map_.next_value()?; + } + } + } + Ok(WorkloadBlockDeviceSpec { + target_path: target_path__.unwrap_or_default(), + device_path: device_path__.unwrap_or_default(), + mount_options: mount_options__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadBlockDeviceSpec", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadBlockDeviceStatus { + #[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.WorkloadBlockDeviceStatus", len)?; + if !self.devices.is_empty() { + struct_ser.serialize_field("devices", &self.devices)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadBlockDeviceStatus { + #[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 = WorkloadBlockDeviceStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadBlockDeviceStatus") + } + + 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(WorkloadBlockDeviceStatus { + devices: devices__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadBlockDeviceStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadChangedEvent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.workload.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadChangedEvent", len)?; + if let Some(v) = self.workload.as_ref() { + struct_ser.serialize_field("workload", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadChangedEvent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "workload", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Workload, + } + 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 { + "workload" => Ok(GeneratedField::Workload), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadChangedEvent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadChangedEvent") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut workload__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Workload => { + if workload__.is_some() { + return Err(serde::de::Error::duplicate_field("workload")); + } + workload__ = map_.next_value()?; + } + } + } + Ok(WorkloadChangedEvent { + workload: workload__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadChangedEvent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadConsoleReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.stdout.is_empty() { + len += 1; + } + if !self.stderr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadConsoleReply", len)?; + if !self.stdout.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("stdout", pbjson::private::base64::encode(&self.stdout).as_str())?; + } + if !self.stderr.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("stderr", pbjson::private::base64::encode(&self.stderr).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadConsoleReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "stdout", + "stderr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Stdout, + Stderr, + } + 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 { + "stdout" => Ok(GeneratedField::Stdout), + "stderr" => Ok(GeneratedField::Stderr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadConsoleReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadConsoleReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut stdout__ = None; + let mut stderr__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Stdout => { + if stdout__.is_some() { + return Err(serde::de::Error::duplicate_field("stdout")); + } + stdout__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Stderr => { + if stderr__.is_some() { + return Err(serde::de::Error::duplicate_field("stderr")); + } + stderr__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(WorkloadConsoleReply { + stdout: stdout__.unwrap_or_default(), + stderr: stderr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadConsoleReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadConsoleRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.workload_id.is_empty() { + len += 1; + } + if !self.stdin.is_empty() { + len += 1; + } + if self.stdin_closed { + len += 1; + } + if self.terminal_resize.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadConsoleRequest", len)?; + if !self.workload_id.is_empty() { + struct_ser.serialize_field("workloadId", &self.workload_id)?; + } + if !self.stdin.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("stdin", pbjson::private::base64::encode(&self.stdin).as_str())?; + } + if self.stdin_closed { + struct_ser.serialize_field("stdinClosed", &self.stdin_closed)?; + } + if let Some(v) = self.terminal_resize.as_ref() { + struct_ser.serialize_field("terminalResize", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadConsoleRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "workload_id", + "workloadId", + "stdin", + "stdin_closed", + "stdinClosed", + "terminal_resize", + "terminalResize", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WorkloadId, + Stdin, + StdinClosed, + TerminalResize, + } + 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 { + "workloadId" | "workload_id" => Ok(GeneratedField::WorkloadId), + "stdin" => Ok(GeneratedField::Stdin), + "stdinClosed" | "stdin_closed" => Ok(GeneratedField::StdinClosed), + "terminalResize" | "terminal_resize" => Ok(GeneratedField::TerminalResize), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadConsoleRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadConsoleRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut workload_id__ = None; + let mut stdin__ = None; + let mut stdin_closed__ = None; + let mut terminal_resize__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::WorkloadId => { + if workload_id__.is_some() { + return Err(serde::de::Error::duplicate_field("workloadId")); + } + workload_id__ = Some(map_.next_value()?); + } + GeneratedField::Stdin => { + if stdin__.is_some() { + return Err(serde::de::Error::duplicate_field("stdin")); + } + stdin__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::StdinClosed => { + if stdin_closed__.is_some() { + return Err(serde::de::Error::duplicate_field("stdinClosed")); + } + stdin_closed__ = Some(map_.next_value()?); + } + GeneratedField::TerminalResize => { + if terminal_resize__.is_some() { + return Err(serde::de::Error::duplicate_field("terminalResize")); + } + terminal_resize__ = map_.next_value()?; + } + } + } + Ok(WorkloadConsoleRequest { + workload_id: workload_id__.unwrap_or_default(), + stdin: stdin__.unwrap_or_default(), + stdin_closed: stdin_closed__.unwrap_or_default(), + terminal_resize: terminal_resize__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadConsoleRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadDeviceInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.info.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadDeviceInfo", len)?; + if let Some(v) = self.info.as_ref() { + match v { + workload_device_info::Info::Block(v) => { + struct_ser.serialize_field("block", v)?; + } + workload_device_info::Info::Fs(v) => { + struct_ser.serialize_field("fs", v)?; + } + workload_device_info::Info::Pci(v) => { + struct_ser.serialize_field("pci", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadDeviceInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "block", + "fs", + "pci", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Block, + Fs, + Pci, + } + 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 { + "block" => Ok(GeneratedField::Block), + "fs" => Ok(GeneratedField::Fs), + "pci" => Ok(GeneratedField::Pci), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadDeviceInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadDeviceInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut info__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Block => { + if info__.is_some() { + return Err(serde::de::Error::duplicate_field("block")); + } + info__ = map_.next_value::<::std::option::Option<_>>()?.map(workload_device_info::Info::Block) +; + } + GeneratedField::Fs => { + if info__.is_some() { + return Err(serde::de::Error::duplicate_field("fs")); + } + info__ = map_.next_value::<::std::option::Option<_>>()?.map(workload_device_info::Info::Fs) +; + } + GeneratedField::Pci => { + if info__.is_some() { + return Err(serde::de::Error::duplicate_field("pci")); + } + info__ = map_.next_value::<::std::option::Option<_>>()?.map(workload_device_info::Info::Pci) +; + } + } + } + Ok(WorkloadDeviceInfo { + info: info__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadDeviceInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadDeviceStatus { + #[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.WorkloadDeviceStatus", len)?; + if !self.devices.is_empty() { + struct_ser.serialize_field("devices", &self.devices)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadDeviceStatus { + #[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 = WorkloadDeviceStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadDeviceStatus") + } + + 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(WorkloadDeviceStatus { + devices: devices__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadDeviceStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadErrorStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.message.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadErrorStatus", len)?; + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadErrorStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Message, + } + 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 { + "message" => Ok(GeneratedField::Message), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadErrorStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadErrorStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = Some(map_.next_value()?); + } + } + } + Ok(WorkloadErrorStatus { + message: message__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadErrorStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadExitStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.code != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadExitStatus", len)?; + if self.code != 0 { + struct_ser.serialize_field("code", &self.code)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadExitStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "code", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Code, + } + 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 { + "code" => Ok(GeneratedField::Code), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadExitStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadExitStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut code__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Code => { + if code__.is_some() { + return Err(serde::de::Error::duplicate_field("code")); + } + code__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(WorkloadExitStatus { + code: code__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadExitStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadFsDeviceInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.device_id != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadFsDeviceInfo", len)?; + if self.device_id != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("deviceId", ToString::to_string(&self.device_id).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadFsDeviceInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "device_id", + "deviceId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + DeviceId, + } + 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 { + "deviceId" | "device_id" => Ok(GeneratedField::DeviceId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadFsDeviceInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadFsDeviceInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut device_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::DeviceId => { + if device_id__.is_some() { + return Err(serde::de::Error::duplicate_field("deviceId")); + } + device_id__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(WorkloadFsDeviceInfo { + device_id: device_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadFsDeviceInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadMountInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.tag.is_empty() { + len += 1; + } + if !self.host_path.is_empty() { + len += 1; + } + if !self.target_path.is_empty() { + len += 1; + } + if self.read_only { + len += 1; + } + if self.cache != 0 { + len += 1; + } + if !self.spec_host_path.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadMountInfo", len)?; + if !self.tag.is_empty() { + struct_ser.serialize_field("tag", &self.tag)?; + } + if !self.host_path.is_empty() { + struct_ser.serialize_field("hostPath", &self.host_path)?; + } + if !self.target_path.is_empty() { + struct_ser.serialize_field("targetPath", &self.target_path)?; + } + if self.read_only { + struct_ser.serialize_field("readOnly", &self.read_only)?; + } + if self.cache != 0 { + let v = MountCacheMode::try_from(self.cache) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache)))?; + struct_ser.serialize_field("cache", &v)?; + } + if !self.spec_host_path.is_empty() { + struct_ser.serialize_field("specHostPath", &self.spec_host_path)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadMountInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "tag", + "host_path", + "hostPath", + "target_path", + "targetPath", + "read_only", + "readOnly", + "cache", + "spec_host_path", + "specHostPath", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Tag, + HostPath, + TargetPath, + ReadOnly, + Cache, + SpecHostPath, + } + 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 { + "tag" => Ok(GeneratedField::Tag), + "hostPath" | "host_path" => Ok(GeneratedField::HostPath), + "targetPath" | "target_path" => Ok(GeneratedField::TargetPath), + "readOnly" | "read_only" => Ok(GeneratedField::ReadOnly), + "cache" => Ok(GeneratedField::Cache), + "specHostPath" | "spec_host_path" => Ok(GeneratedField::SpecHostPath), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadMountInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadMountInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut tag__ = None; + let mut host_path__ = None; + let mut target_path__ = None; + let mut read_only__ = None; + let mut cache__ = None; + let mut spec_host_path__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Tag => { + if tag__.is_some() { + return Err(serde::de::Error::duplicate_field("tag")); + } + tag__ = Some(map_.next_value()?); + } + GeneratedField::HostPath => { + if host_path__.is_some() { + return Err(serde::de::Error::duplicate_field("hostPath")); + } + host_path__ = Some(map_.next_value()?); + } + GeneratedField::TargetPath => { + if target_path__.is_some() { + return Err(serde::de::Error::duplicate_field("targetPath")); + } + target_path__ = Some(map_.next_value()?); + } + GeneratedField::ReadOnly => { + if read_only__.is_some() { + return Err(serde::de::Error::duplicate_field("readOnly")); + } + read_only__ = Some(map_.next_value()?); + } + GeneratedField::Cache => { + if cache__.is_some() { + return Err(serde::de::Error::duplicate_field("cache")); + } + cache__ = Some(map_.next_value::()? as i32); + } + GeneratedField::SpecHostPath => { + if spec_host_path__.is_some() { + return Err(serde::de::Error::duplicate_field("specHostPath")); + } + spec_host_path__ = Some(map_.next_value()?); + } + } + } + Ok(WorkloadMountInfo { + tag: tag__.unwrap_or_default(), + host_path: host_path__.unwrap_or_default(), + target_path: target_path__.unwrap_or_default(), + read_only: read_only__.unwrap_or_default(), + cache: cache__.unwrap_or_default(), + spec_host_path: spec_host_path__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadMountInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadMountStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.mounts.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadMountStatus", len)?; + if !self.mounts.is_empty() { + struct_ser.serialize_field("mounts", &self.mounts)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadMountStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "mounts", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Mounts, + } + 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 { + "mounts" => Ok(GeneratedField::Mounts), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadMountStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadMountStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut mounts__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Mounts => { + if mounts__.is_some() { + return Err(serde::de::Error::duplicate_field("mounts")); + } + mounts__ = Some(map_.next_value()?); + } + } + } + Ok(WorkloadMountStatus { + mounts: mounts__.unwrap_or_default(), + }) + } + } + 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 + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.path.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadScratchMount", len)?; + if !self.path.is_empty() { + struct_ser.serialize_field("path", &self.path)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadScratchMount { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "path", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Path, + } + 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 { + "path" => Ok(GeneratedField::Path), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadScratchMount; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadScratchMount") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut path__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Path => { + if path__.is_some() { + return Err(serde::de::Error::duplicate_field("path")); + } + path__ = Some(map_.next_value()?); + } + } + } + Ok(WorkloadScratchMount { + path: path__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadScratchMount", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadSecuritySpec { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.strict_user_namespace { + len += 1; + } + if !self.raise_capabilities.is_empty() { + len += 1; + } + if !self.raise_ambient_capabilities.is_empty() { + len += 1; + } + if !self.drop_capabilities.is_empty() { + len += 1; + } + if self.privileged { + len += 1; + } + if self.disable_all_namespaces { + len += 1; + } + if !self.disable_namespaces.is_empty() { + len += 1; + } + if self.read_only_rootfs { + len += 1; + } + if self.no_new_privs { + len += 1; + } + if self.seccomp_profile_type != 0 { + len += 1; + } + if !self.seccomp_localhost_ref.is_empty() { + len += 1; + } + if self.apparmor_profile_type != 0 { + len += 1; + } + if self.resolved_seccomp_profile.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadSecuritySpec", len)?; + if self.strict_user_namespace { + struct_ser.serialize_field("strictUserNamespace", &self.strict_user_namespace)?; + } + if !self.raise_capabilities.is_empty() { + struct_ser.serialize_field("raiseCapabilities", &self.raise_capabilities)?; + } + if !self.raise_ambient_capabilities.is_empty() { + struct_ser.serialize_field("raiseAmbientCapabilities", &self.raise_ambient_capabilities)?; + } + if !self.drop_capabilities.is_empty() { + struct_ser.serialize_field("dropCapabilities", &self.drop_capabilities)?; + } + if self.privileged { + struct_ser.serialize_field("privileged", &self.privileged)?; + } + if self.disable_all_namespaces { + struct_ser.serialize_field("disableAllNamespaces", &self.disable_all_namespaces)?; + } + if !self.disable_namespaces.is_empty() { + let v = self.disable_namespaces.iter().cloned().map(|v| { + ProcessNamespace::try_from(v) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v))) + }).collect::, _>>()?; + struct_ser.serialize_field("disableNamespaces", &v)?; + } + if self.read_only_rootfs { + struct_ser.serialize_field("readOnlyRootfs", &self.read_only_rootfs)?; + } + if self.no_new_privs { + struct_ser.serialize_field("noNewPrivs", &self.no_new_privs)?; + } + if self.seccomp_profile_type != 0 { + let v = SeccompProfileType::try_from(self.seccomp_profile_type) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.seccomp_profile_type)))?; + struct_ser.serialize_field("seccompProfileType", &v)?; + } + if !self.seccomp_localhost_ref.is_empty() { + struct_ser.serialize_field("seccompLocalhostRef", &self.seccomp_localhost_ref)?; + } + if self.apparmor_profile_type != 0 { + let v = AppArmorProfileType::try_from(self.apparmor_profile_type) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.apparmor_profile_type)))?; + struct_ser.serialize_field("apparmorProfileType", &v)?; + } + if let Some(v) = self.resolved_seccomp_profile.as_ref() { + struct_ser.serialize_field("resolvedSeccompProfile", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadSecuritySpec { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "strict_user_namespace", + "strictUserNamespace", + "raise_capabilities", + "raiseCapabilities", + "raise_ambient_capabilities", + "raiseAmbientCapabilities", + "drop_capabilities", + "dropCapabilities", + "privileged", + "disable_all_namespaces", + "disableAllNamespaces", + "disable_namespaces", + "disableNamespaces", + "read_only_rootfs", + "readOnlyRootfs", + "no_new_privs", + "noNewPrivs", + "seccomp_profile_type", + "seccompProfileType", + "seccomp_localhost_ref", + "seccompLocalhostRef", + "apparmor_profile_type", + "apparmorProfileType", + "resolved_seccomp_profile", + "resolvedSeccompProfile", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + StrictUserNamespace, + RaiseCapabilities, + RaiseAmbientCapabilities, + DropCapabilities, + Privileged, + DisableAllNamespaces, + DisableNamespaces, + ReadOnlyRootfs, + NoNewPrivs, + SeccompProfileType, + SeccompLocalhostRef, + ApparmorProfileType, + ResolvedSeccompProfile, + } + 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 { + "strictUserNamespace" | "strict_user_namespace" => Ok(GeneratedField::StrictUserNamespace), + "raiseCapabilities" | "raise_capabilities" => Ok(GeneratedField::RaiseCapabilities), + "raiseAmbientCapabilities" | "raise_ambient_capabilities" => Ok(GeneratedField::RaiseAmbientCapabilities), + "dropCapabilities" | "drop_capabilities" => Ok(GeneratedField::DropCapabilities), + "privileged" => Ok(GeneratedField::Privileged), + "disableAllNamespaces" | "disable_all_namespaces" => Ok(GeneratedField::DisableAllNamespaces), + "disableNamespaces" | "disable_namespaces" => Ok(GeneratedField::DisableNamespaces), + "readOnlyRootfs" | "read_only_rootfs" => Ok(GeneratedField::ReadOnlyRootfs), + "noNewPrivs" | "no_new_privs" => Ok(GeneratedField::NoNewPrivs), + "seccompProfileType" | "seccomp_profile_type" => Ok(GeneratedField::SeccompProfileType), + "seccompLocalhostRef" | "seccomp_localhost_ref" => Ok(GeneratedField::SeccompLocalhostRef), + "apparmorProfileType" | "apparmor_profile_type" => Ok(GeneratedField::ApparmorProfileType), + "resolvedSeccompProfile" | "resolved_seccomp_profile" => Ok(GeneratedField::ResolvedSeccompProfile), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadSecuritySpec; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadSecuritySpec") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut strict_user_namespace__ = None; + let mut raise_capabilities__ = None; + let mut raise_ambient_capabilities__ = None; + let mut drop_capabilities__ = None; + let mut privileged__ = None; + let mut disable_all_namespaces__ = None; + let mut disable_namespaces__ = None; + let mut read_only_rootfs__ = None; + let mut no_new_privs__ = None; + let mut seccomp_profile_type__ = None; + let mut seccomp_localhost_ref__ = None; + let mut apparmor_profile_type__ = None; + let mut resolved_seccomp_profile__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::StrictUserNamespace => { + if strict_user_namespace__.is_some() { + return Err(serde::de::Error::duplicate_field("strictUserNamespace")); + } + strict_user_namespace__ = Some(map_.next_value()?); + } + GeneratedField::RaiseCapabilities => { + if raise_capabilities__.is_some() { + return Err(serde::de::Error::duplicate_field("raiseCapabilities")); + } + raise_capabilities__ = Some(map_.next_value()?); + } + GeneratedField::RaiseAmbientCapabilities => { + if raise_ambient_capabilities__.is_some() { + return Err(serde::de::Error::duplicate_field("raiseAmbientCapabilities")); + } + raise_ambient_capabilities__ = Some(map_.next_value()?); + } + GeneratedField::DropCapabilities => { + if drop_capabilities__.is_some() { + return Err(serde::de::Error::duplicate_field("dropCapabilities")); + } + drop_capabilities__ = Some(map_.next_value()?); + } + GeneratedField::Privileged => { + if privileged__.is_some() { + return Err(serde::de::Error::duplicate_field("privileged")); + } + privileged__ = Some(map_.next_value()?); + } + GeneratedField::DisableAllNamespaces => { + if disable_all_namespaces__.is_some() { + return Err(serde::de::Error::duplicate_field("disableAllNamespaces")); + } + disable_all_namespaces__ = Some(map_.next_value()?); + } + GeneratedField::DisableNamespaces => { + if disable_namespaces__.is_some() { + return Err(serde::de::Error::duplicate_field("disableNamespaces")); + } + disable_namespaces__ = Some(map_.next_value::>()?.into_iter().map(|x| x as i32).collect()); + } + GeneratedField::ReadOnlyRootfs => { + if read_only_rootfs__.is_some() { + return Err(serde::de::Error::duplicate_field("readOnlyRootfs")); + } + read_only_rootfs__ = Some(map_.next_value()?); + } + GeneratedField::NoNewPrivs => { + if no_new_privs__.is_some() { + return Err(serde::de::Error::duplicate_field("noNewPrivs")); + } + no_new_privs__ = Some(map_.next_value()?); + } + GeneratedField::SeccompProfileType => { + if seccomp_profile_type__.is_some() { + return Err(serde::de::Error::duplicate_field("seccompProfileType")); + } + seccomp_profile_type__ = Some(map_.next_value::()? as i32); + } + GeneratedField::SeccompLocalhostRef => { + if seccomp_localhost_ref__.is_some() { + return Err(serde::de::Error::duplicate_field("seccompLocalhostRef")); + } + seccomp_localhost_ref__ = Some(map_.next_value()?); + } + GeneratedField::ApparmorProfileType => { + if apparmor_profile_type__.is_some() { + return Err(serde::de::Error::duplicate_field("apparmorProfileType")); + } + apparmor_profile_type__ = Some(map_.next_value::()? as i32); + } + GeneratedField::ResolvedSeccompProfile => { + if resolved_seccomp_profile__.is_some() { + return Err(serde::de::Error::duplicate_field("resolvedSeccompProfile")); + } + resolved_seccomp_profile__ = map_.next_value()?; + } + } + } + Ok(WorkloadSecuritySpec { + strict_user_namespace: strict_user_namespace__.unwrap_or_default(), + raise_capabilities: raise_capabilities__.unwrap_or_default(), + raise_ambient_capabilities: raise_ambient_capabilities__.unwrap_or_default(), + drop_capabilities: drop_capabilities__.unwrap_or_default(), + privileged: privileged__.unwrap_or_default(), + disable_all_namespaces: disable_all_namespaces__.unwrap_or_default(), + disable_namespaces: disable_namespaces__.unwrap_or_default(), + read_only_rootfs: read_only_rootfs__.unwrap_or_default(), + no_new_privs: no_new_privs__.unwrap_or_default(), + seccomp_profile_type: seccomp_profile_type__.unwrap_or_default(), + seccomp_localhost_ref: seccomp_localhost_ref__.unwrap_or_default(), + apparmor_profile_type: apparmor_profile_type__.unwrap_or_default(), + resolved_seccomp_profile: resolved_seccomp_profile__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadSecuritySpec", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadSpec { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if !self.zone_id.is_empty() { + len += 1; + } + if self.image.is_some() { + len += 1; + } + if self.process.is_some() { + len += 1; + } + if !self.annotations.is_empty() { + len += 1; + } + if !self.mounts.is_empty() { + len += 1; + } + if self.security.is_some() { + len += 1; + } + if !self.scratch_mount.is_empty() { + len += 1; + } + if !self.cgroup_limits.is_empty() { + len += 1; + } + if !self.hostname.is_empty() { + len += 1; + } + 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; + } + if self.object_capabilities.is_some() { + 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)?; + } + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if let Some(v) = self.image.as_ref() { + struct_ser.serialize_field("image", v)?; + } + if let Some(v) = self.process.as_ref() { + struct_ser.serialize_field("process", v)?; + } + if !self.annotations.is_empty() { + struct_ser.serialize_field("annotations", &self.annotations)?; + } + if !self.mounts.is_empty() { + struct_ser.serialize_field("mounts", &self.mounts)?; + } + if let Some(v) = self.security.as_ref() { + struct_ser.serialize_field("security", v)?; + } + if !self.scratch_mount.is_empty() { + struct_ser.serialize_field("scratchMount", &self.scratch_mount)?; + } + if !self.cgroup_limits.is_empty() { + struct_ser.serialize_field("cgroupLimits", &self.cgroup_limits)?; + } + if !self.hostname.is_empty() { + struct_ser.serialize_field("hostname", &self.hostname)?; + } + 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)?; + } + if let Some(v) = self.object_capabilities.as_ref() { + struct_ser.serialize_field("objectCapabilities", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadSpec { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "zone_id", + "zoneId", + "image", + "process", + "annotations", + "mounts", + "security", + "scratch_mount", + "scratchMount", + "cgroup_limits", + "cgroupLimits", + "hostname", + "block_devices", + "blockDevices", + "oom_score_adj", + "oomScoreAdj", + "pci_devices", + "pciDevices", + "object_capabilities", + "objectCapabilities", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + ZoneId, + Image, + Process, + Annotations, + Mounts, + Security, + ScratchMount, + CgroupLimits, + Hostname, + BlockDevices, + OomScoreAdj, + PciDevices, + ObjectCapabilities, + } + 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 { + "name" => Ok(GeneratedField::Name), + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "image" => Ok(GeneratedField::Image), + "process" => Ok(GeneratedField::Process), + "annotations" => Ok(GeneratedField::Annotations), + "mounts" => Ok(GeneratedField::Mounts), + "security" => Ok(GeneratedField::Security), + "scratchMount" | "scratch_mount" => Ok(GeneratedField::ScratchMount), + "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), + "objectCapabilities" | "object_capabilities" => Ok(GeneratedField::ObjectCapabilities), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadSpec; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadSpec") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut zone_id__ = None; + let mut image__ = None; + let mut process__ = None; + let mut annotations__ = None; + let mut mounts__ = None; + let mut security__ = None; + let mut scratch_mount__ = None; + 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; + let mut object_capabilities__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Image => { + if image__.is_some() { + return Err(serde::de::Error::duplicate_field("image")); + } + image__ = map_.next_value()?; + } + GeneratedField::Process => { + if process__.is_some() { + return Err(serde::de::Error::duplicate_field("process")); + } + process__ = map_.next_value()?; + } + GeneratedField::Annotations => { + if annotations__.is_some() { + return Err(serde::de::Error::duplicate_field("annotations")); + } + annotations__ = Some(map_.next_value()?); + } + GeneratedField::Mounts => { + if mounts__.is_some() { + return Err(serde::de::Error::duplicate_field("mounts")); + } + mounts__ = Some(map_.next_value()?); + } + GeneratedField::Security => { + if security__.is_some() { + return Err(serde::de::Error::duplicate_field("security")); + } + security__ = map_.next_value()?; + } + GeneratedField::ScratchMount => { + if scratch_mount__.is_some() { + return Err(serde::de::Error::duplicate_field("scratchMount")); + } + scratch_mount__ = Some(map_.next_value()?); + } + GeneratedField::CgroupLimits => { + if cgroup_limits__.is_some() { + return Err(serde::de::Error::duplicate_field("cgroupLimits")); + } + cgroup_limits__ = Some(map_.next_value()?); + } + GeneratedField::Hostname => { + if hostname__.is_some() { + return Err(serde::de::Error::duplicate_field("hostname")); + } + hostname__ = Some(map_.next_value()?); + } + GeneratedField::BlockDevices => { + if block_devices__.is_some() { + return Err(serde::de::Error::duplicate_field("blockDevices")); + } + 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()?); + } + GeneratedField::ObjectCapabilities => { + if object_capabilities__.is_some() { + return Err(serde::de::Error::duplicate_field("objectCapabilities")); + } + object_capabilities__ = map_.next_value()?; + } + } + } + Ok(WorkloadSpec { + name: name__.unwrap_or_default(), + zone_id: zone_id__.unwrap_or_default(), + image: image__, + process: process__, + annotations: annotations__.unwrap_or_default(), + mounts: mounts__.unwrap_or_default(), + security: security__, + scratch_mount: scratch_mount__.unwrap_or_default(), + 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(), + object_capabilities: object_capabilities__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadSpec", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadState { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "WORKLOAD_STATE_UNKNOWN", + Self::Creating => "WORKLOAD_STATE_CREATING", + Self::Created => "WORKLOAD_STATE_CREATED", + Self::Running => "WORKLOAD_STATE_RUNNING", + Self::Completed => "WORKLOAD_STATE_COMPLETED", + Self::Destroying => "WORKLOAD_STATE_DESTROYING", + Self::Destroyed => "WORKLOAD_STATE_DESTROYED", + Self::Failed => "WORKLOAD_STATE_FAILED", + Self::Oomkilled => "WORKLOAD_STATE_OOMKILLED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for WorkloadState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "WORKLOAD_STATE_UNKNOWN", + "WORKLOAD_STATE_CREATING", + "WORKLOAD_STATE_CREATED", + "WORKLOAD_STATE_RUNNING", + "WORKLOAD_STATE_COMPLETED", + "WORKLOAD_STATE_DESTROYING", + "WORKLOAD_STATE_DESTROYED", + "WORKLOAD_STATE_FAILED", + "WORKLOAD_STATE_OOMKILLED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadState; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "WORKLOAD_STATE_UNKNOWN" => Ok(WorkloadState::Unknown), + "WORKLOAD_STATE_CREATING" => Ok(WorkloadState::Creating), + "WORKLOAD_STATE_CREATED" => Ok(WorkloadState::Created), + "WORKLOAD_STATE_RUNNING" => Ok(WorkloadState::Running), + "WORKLOAD_STATE_COMPLETED" => Ok(WorkloadState::Completed), + "WORKLOAD_STATE_DESTROYING" => Ok(WorkloadState::Destroying), + "WORKLOAD_STATE_DESTROYED" => Ok(WorkloadState::Destroyed), + "WORKLOAD_STATE_FAILED" => Ok(WorkloadState::Failed), + "WORKLOAD_STATE_OOMKILLED" => Ok(WorkloadState::Oomkilled), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.state != 0 { + len += 1; + } + if self.exit_status.is_some() { + len += 1; + } + if self.error_status.is_some() { + len += 1; + } + if self.block_device_status.is_some() { + len += 1; + } + if self.mount_status.is_some() { + len += 1; + } + if self.created_at.is_some() { + len += 1; + } + if self.pci_device_status.is_some() { + len += 1; + } + if self.device_status.is_some() { + len += 1; + } + if self.user_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) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?; + struct_ser.serialize_field("state", &v)?; + } + if let Some(v) = self.exit_status.as_ref() { + struct_ser.serialize_field("exitStatus", v)?; + } + if let Some(v) = self.error_status.as_ref() { + struct_ser.serialize_field("errorStatus", v)?; + } + if let Some(v) = self.block_device_status.as_ref() { + struct_ser.serialize_field("blockDeviceStatus", v)?; + } + if let Some(v) = self.mount_status.as_ref() { + struct_ser.serialize_field("mountStatus", v)?; + } + 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)?; + } + if let Some(v) = self.device_status.as_ref() { + struct_ser.serialize_field("deviceStatus", v)?; + } + if let Some(v) = self.user_status.as_ref() { + struct_ser.serialize_field("userStatus", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "state", + "exit_status", + "exitStatus", + "error_status", + "errorStatus", + "block_device_status", + "blockDeviceStatus", + "mount_status", + "mountStatus", + "created_at", + "createdAt", + "pci_device_status", + "pciDeviceStatus", + "device_status", + "deviceStatus", + "user_status", + "userStatus", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + State, + ExitStatus, + ErrorStatus, + BlockDeviceStatus, + MountStatus, + CreatedAt, + PciDeviceStatus, + DeviceStatus, + UserStatus, + } + 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 { + "state" => Ok(GeneratedField::State), + "exitStatus" | "exit_status" => Ok(GeneratedField::ExitStatus), + "errorStatus" | "error_status" => Ok(GeneratedField::ErrorStatus), + "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), + "deviceStatus" | "device_status" => Ok(GeneratedField::DeviceStatus), + "userStatus" | "user_status" => Ok(GeneratedField::UserStatus), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut state__ = None; + let mut exit_status__ = None; + let mut error_status__ = None; + let mut block_device_status__ = None; + let mut mount_status__ = None; + let mut created_at__ = None; + let mut pci_device_status__ = None; + let mut device_status__ = None; + let mut user_status__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::State => { + if state__.is_some() { + return Err(serde::de::Error::duplicate_field("state")); + } + state__ = Some(map_.next_value::()? as i32); + } + GeneratedField::ExitStatus => { + if exit_status__.is_some() { + return Err(serde::de::Error::duplicate_field("exitStatus")); + } + exit_status__ = map_.next_value()?; + } + GeneratedField::ErrorStatus => { + if error_status__.is_some() { + return Err(serde::de::Error::duplicate_field("errorStatus")); + } + error_status__ = map_.next_value()?; + } + GeneratedField::BlockDeviceStatus => { + if block_device_status__.is_some() { + return Err(serde::de::Error::duplicate_field("blockDeviceStatus")); + } + block_device_status__ = map_.next_value()?; + } + GeneratedField::MountStatus => { + if mount_status__.is_some() { + return Err(serde::de::Error::duplicate_field("mountStatus")); + } + mount_status__ = map_.next_value()?; + } + GeneratedField::CreatedAt => { + if created_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createdAt")); + } + 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()?; + } + GeneratedField::DeviceStatus => { + if device_status__.is_some() { + return Err(serde::de::Error::duplicate_field("deviceStatus")); + } + device_status__ = map_.next_value()?; + } + GeneratedField::UserStatus => { + if user_status__.is_some() { + return Err(serde::de::Error::duplicate_field("userStatus")); + } + user_status__ = map_.next_value()?; + } + } + } + Ok(WorkloadStatus { + state: state__.unwrap_or_default(), + exit_status: exit_status__, + error_status: error_status__, + block_device_status: block_device_status__, + mount_status: mount_status__, + created_at: created_at__, + pci_device_status: pci_device_status__, + device_status: device_status__, + user_status: user_status__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WorkloadUserStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.uid != 0 { + len += 1; + } + if self.gid != 0 { + len += 1; + } + if !self.supplemental_gids.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.WorkloadUserStatus", len)?; + if self.uid != 0 { + struct_ser.serialize_field("uid", &self.uid)?; + } + if self.gid != 0 { + struct_ser.serialize_field("gid", &self.gid)?; + } + if !self.supplemental_gids.is_empty() { + struct_ser.serialize_field("supplementalGids", &self.supplemental_gids)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WorkloadUserStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "uid", + "gid", + "supplemental_gids", + "supplementalGids", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Uid, + Gid, + SupplementalGids, + } + 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 { + "uid" => Ok(GeneratedField::Uid), + "gid" => Ok(GeneratedField::Gid), + "supplementalGids" | "supplemental_gids" => Ok(GeneratedField::SupplementalGids), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WorkloadUserStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.WorkloadUserStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut uid__ = None; + let mut gid__ = None; + let mut supplemental_gids__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Uid => { + if uid__.is_some() { + return Err(serde::de::Error::duplicate_field("uid")); + } + uid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Gid => { + if gid__.is_some() { + return Err(serde::de::Error::duplicate_field("gid")); + } + gid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::SupplementalGids => { + if supplemental_gids__.is_some() { + return Err(serde::de::Error::duplicate_field("supplementalGids")); + } + supplemental_gids__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(WorkloadUserStatus { + uid: uid__.unwrap_or_default(), + gid: gid__.unwrap_or_default(), + supplemental_gids: supplemental_gids__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.WorkloadUserStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Zone { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if self.spec.is_some() { + len += 1; + } + if self.status.is_some() { + len += 1; + } + if self.origin.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.Zone", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if let Some(v) = self.spec.as_ref() { + struct_ser.serialize_field("spec", v)?; + } + if let Some(v) = self.status.as_ref() { + struct_ser.serialize_field("status", v)?; + } + if let Some(v) = self.origin.as_ref() { + struct_ser.serialize_field("origin", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Zone { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "spec", + "status", + "origin", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + Spec, + Status, + Origin, + } + 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 { + "id" => Ok(GeneratedField::Id), + "spec" => Ok(GeneratedField::Spec), + "status" => Ok(GeneratedField::Status), + "origin" => Ok(GeneratedField::Origin), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Zone; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.Zone") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut spec__ = None; + let mut status__ = None; + let mut origin__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::Spec => { + if spec__.is_some() { + return Err(serde::de::Error::duplicate_field("spec")); + } + spec__ = map_.next_value()?; + } + GeneratedField::Status => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("status")); + } + status__ = map_.next_value()?; + } + GeneratedField::Origin => { + if origin__.is_some() { + return Err(serde::de::Error::duplicate_field("origin")); + } + origin__ = map_.next_value()?; + } + } + } + Ok(Zone { + id: id__.unwrap_or_default(), + spec: spec__, + status: status__, + origin: origin__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.Zone", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneChangedEvent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.zone.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneChangedEvent", len)?; + if let Some(v) = self.zone.as_ref() { + struct_ser.serialize_field("zone", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneChangedEvent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Zone, + } + 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 { + "zone" => Ok(GeneratedField::Zone), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneChangedEvent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneChangedEvent") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Zone => { + if zone__.is_some() { + return Err(serde::de::Error::duplicate_field("zone")); + } + zone__ = map_.next_value()?; + } + } + } + Ok(ZoneChangedEvent { + zone: zone__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneChangedEvent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneConsoleReply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.data.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneConsoleReply", len)?; + if !self.data.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneConsoleReply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "data", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Data, + } + 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 { + "data" => Ok(GeneratedField::Data), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneConsoleReply; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneConsoleReply") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut data__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Data => { + if data__.is_some() { + return Err(serde::de::Error::duplicate_field("data")); + } + data__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(ZoneConsoleReply { + data: data__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneConsoleReply", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneConsoleRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if !self.data.is_empty() { + len += 1; + } + if self.replay_history { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneConsoleRequest", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.data.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; + } + if self.replay_history { + struct_ser.serialize_field("replayHistory", &self.replay_history)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneConsoleRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "data", + "replay_history", + "replayHistory", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + Data, + ReplayHistory, + } + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "data" => Ok(GeneratedField::Data), + "replayHistory" | "replay_history" => Ok(GeneratedField::ReplayHistory), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneConsoleRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneConsoleRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut data__ = None; + let mut replay_history__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Data => { + if data__.is_some() { + return Err(serde::de::Error::duplicate_field("data")); + } + data__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::ReplayHistory => { + if replay_history__.is_some() { + return Err(serde::de::Error::duplicate_field("replayHistory")); + } + replay_history__ = Some(map_.next_value()?); + } + } + } + Ok(ZoneConsoleRequest { + zone_id: zone_id__.unwrap_or_default(), + data: data__.unwrap_or_default(), + replay_history: replay_history__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneConsoleRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneDeviceStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.disks.is_empty() { + len += 1; + } + if self.mount.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneDeviceStatus", len)?; + if !self.disks.is_empty() { + struct_ser.serialize_field("disks", &self.disks)?; + } + if let Some(v) = self.mount.as_ref() { + struct_ser.serialize_field("mount", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneDeviceStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "disks", + "mount", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Disks, + Mount, + } + 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 { + "disks" => Ok(GeneratedField::Disks), + "mount" => Ok(GeneratedField::Mount), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneDeviceStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneDeviceStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut disks__ = None; + let mut mount__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Disks => { + if disks__.is_some() { + return Err(serde::de::Error::duplicate_field("disks")); + } + disks__ = Some(map_.next_value()?); + } + GeneratedField::Mount => { + if mount__.is_some() { + return Err(serde::de::Error::duplicate_field("mount")); + } + mount__ = map_.next_value()?; + } + } + } + Ok(ZoneDeviceStatus { + disks: disks__.unwrap_or_default(), + mount: mount__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneDeviceStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneDiskStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_block_device.is_empty() { + len += 1; + } + if !self.host_block_device.is_empty() { + len += 1; + } + if !self.host_image_file.is_empty() { + len += 1; + } + if !self.filesystem_type.is_empty() { + len += 1; + } + if self.purpose != 0 { + len += 1; + } + if self.delete { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneDiskStatus", len)?; + if !self.zone_block_device.is_empty() { + struct_ser.serialize_field("zoneBlockDevice", &self.zone_block_device)?; + } + if !self.host_block_device.is_empty() { + struct_ser.serialize_field("hostBlockDevice", &self.host_block_device)?; + } + if !self.host_image_file.is_empty() { + struct_ser.serialize_field("hostImageFile", &self.host_image_file)?; + } + if !self.filesystem_type.is_empty() { + struct_ser.serialize_field("filesystemType", &self.filesystem_type)?; + } + if self.purpose != 0 { + let v = ZoneDiskStatusDiskPurpose::try_from(self.purpose) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.purpose)))?; + struct_ser.serialize_field("purpose", &v)?; + } + if self.delete { + struct_ser.serialize_field("delete", &self.delete)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneDiskStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_block_device", + "zoneBlockDevice", + "host_block_device", + "hostBlockDevice", + "host_image_file", + "hostImageFile", + "filesystem_type", + "filesystemType", + "purpose", + "delete", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneBlockDevice, + HostBlockDevice, + HostImageFile, + FilesystemType, + Purpose, + Delete, + } + 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 { + "zoneBlockDevice" | "zone_block_device" => Ok(GeneratedField::ZoneBlockDevice), + "hostBlockDevice" | "host_block_device" => Ok(GeneratedField::HostBlockDevice), + "hostImageFile" | "host_image_file" => Ok(GeneratedField::HostImageFile), + "filesystemType" | "filesystem_type" => Ok(GeneratedField::FilesystemType), + "purpose" => Ok(GeneratedField::Purpose), + "delete" => Ok(GeneratedField::Delete), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneDiskStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneDiskStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_block_device__ = None; + let mut host_block_device__ = None; + let mut host_image_file__ = None; + let mut filesystem_type__ = None; + let mut purpose__ = None; + let mut delete__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneBlockDevice => { + if zone_block_device__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneBlockDevice")); + } + zone_block_device__ = Some(map_.next_value()?); + } + GeneratedField::HostBlockDevice => { + if host_block_device__.is_some() { + return Err(serde::de::Error::duplicate_field("hostBlockDevice")); + } + host_block_device__ = Some(map_.next_value()?); + } + GeneratedField::HostImageFile => { + if host_image_file__.is_some() { + return Err(serde::de::Error::duplicate_field("hostImageFile")); + } + host_image_file__ = Some(map_.next_value()?); + } + GeneratedField::FilesystemType => { + if filesystem_type__.is_some() { + return Err(serde::de::Error::duplicate_field("filesystemType")); + } + filesystem_type__ = Some(map_.next_value()?); + } + GeneratedField::Purpose => { + if purpose__.is_some() { + return Err(serde::de::Error::duplicate_field("purpose")); + } + purpose__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Delete => { + if delete__.is_some() { + return Err(serde::de::Error::duplicate_field("delete")); + } + delete__ = Some(map_.next_value()?); + } + } + } + Ok(ZoneDiskStatus { + zone_block_device: zone_block_device__.unwrap_or_default(), + host_block_device: host_block_device__.unwrap_or_default(), + host_image_file: host_image_file__.unwrap_or_default(), + filesystem_type: filesystem_type__.unwrap_or_default(), + purpose: purpose__.unwrap_or_default(), + delete: delete__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneDiskStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneDiskStatusDiskPurpose { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "ZONE_DISK_STATUS_DISK_PURPOSE_UNKNOWN", + Self::Addons => "ZONE_DISK_STATUS_DISK_PURPOSE_ADDONS", + Self::Scratch => "ZONE_DISK_STATUS_DISK_PURPOSE_SCRATCH", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneDiskStatusDiskPurpose { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_DISK_STATUS_DISK_PURPOSE_UNKNOWN", + "ZONE_DISK_STATUS_DISK_PURPOSE_ADDONS", + "ZONE_DISK_STATUS_DISK_PURPOSE_SCRATCH", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneDiskStatusDiskPurpose; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_DISK_STATUS_DISK_PURPOSE_UNKNOWN" => Ok(ZoneDiskStatusDiskPurpose::Unknown), + "ZONE_DISK_STATUS_DISK_PURPOSE_ADDONS" => Ok(ZoneDiskStatusDiskPurpose::Addons), + "ZONE_DISK_STATUS_DISK_PURPOSE_SCRATCH" => Ok(ZoneDiskStatusDiskPurpose::Scratch), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ZoneErrorReason { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "ZONE_ERROR_REASON_UNKNOWN", + Self::InsufficientMemory => "ZONE_ERROR_REASON_INSUFFICIENT_MEMORY", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneErrorReason { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_ERROR_REASON_UNKNOWN", + "ZONE_ERROR_REASON_INSUFFICIENT_MEMORY", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneErrorReason; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_ERROR_REASON_UNKNOWN" => Ok(ZoneErrorReason::Unknown), + "ZONE_ERROR_REASON_INSUFFICIENT_MEMORY" => Ok(ZoneErrorReason::InsufficientMemory), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ZoneErrorStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.message.is_empty() { + len += 1; + } + if self.reason != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneErrorStatus", len)?; + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; + } + if self.reason != 0 { + let v = ZoneErrorReason::try_from(self.reason) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.reason)))?; + struct_ser.serialize_field("reason", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneErrorStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message", + "reason", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Message, + Reason, + } + 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 { + "message" => Ok(GeneratedField::Message), + "reason" => Ok(GeneratedField::Reason), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneErrorStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneErrorStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message__ = None; + let mut reason__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = Some(map_.next_value()?); + } + GeneratedField::Reason => { + if reason__.is_some() { + return Err(serde::de::Error::duplicate_field("reason")); + } + reason__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(ZoneErrorStatus { + message: message__.unwrap_or_default(), + reason: reason__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneErrorStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneExitStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.code != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneExitStatus", len)?; + if self.code != 0 { + struct_ser.serialize_field("code", &self.code)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneExitStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "code", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Code, + } + 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 { + "code" => Ok(GeneratedField::Code), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneExitStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneExitStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut code__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Code => { + if code__.is_some() { + return Err(serde::de::Error::duplicate_field("code")); + } + code__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(ZoneExitStatus { + code: code__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneExitStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelEventParam { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if self.param_type != 0 { + len += 1; + } + if !self.param_data.is_empty() { + len += 1; + } + if !self.param_pretty.is_empty() { + len += 1; + } + if !self.param_type_pretty.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelEventParam", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if self.param_type != 0 { + struct_ser.serialize_field("paramType", &self.param_type)?; + } + if !self.param_data.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("paramData", pbjson::private::base64::encode(&self.param_data).as_str())?; + } + if !self.param_pretty.is_empty() { + struct_ser.serialize_field("paramPretty", &self.param_pretty)?; + } + if !self.param_type_pretty.is_empty() { + struct_ser.serialize_field("paramTypePretty", &self.param_type_pretty)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelEventParam { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "param_type", + "paramType", + "param_data", + "paramData", + "param_pretty", + "paramPretty", + "param_type_pretty", + "paramTypePretty", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + ParamType, + ParamData, + ParamPretty, + ParamTypePretty, + } + 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 { + "name" => Ok(GeneratedField::Name), + "paramType" | "param_type" => Ok(GeneratedField::ParamType), + "paramData" | "param_data" => Ok(GeneratedField::ParamData), + "paramPretty" | "param_pretty" => Ok(GeneratedField::ParamPretty), + "paramTypePretty" | "param_type_pretty" => Ok(GeneratedField::ParamTypePretty), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelEventParam; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelEventParam") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut param_type__ = None; + let mut param_data__ = None; + let mut param_pretty__ = None; + let mut param_type_pretty__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::ParamType => { + if param_type__.is_some() { + return Err(serde::de::Error::duplicate_field("paramType")); + } + param_type__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ParamData => { + if param_data__.is_some() { + return Err(serde::de::Error::duplicate_field("paramData")); + } + param_data__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::ParamPretty => { + if param_pretty__.is_some() { + return Err(serde::de::Error::duplicate_field("paramPretty")); + } + param_pretty__ = Some(map_.next_value()?); + } + GeneratedField::ParamTypePretty => { + if param_type_pretty__.is_some() { + return Err(serde::de::Error::duplicate_field("paramTypePretty")); + } + param_type_pretty__ = Some(map_.next_value()?); + } + } + } + Ok(ZoneKernelEventParam { + name: name__.unwrap_or_default(), + param_type: param_type__.unwrap_or_default(), + param_data: param_data__.unwrap_or_default(), + param_pretty: param_pretty__.unwrap_or_default(), + param_type_pretty: param_type_pretty__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelEventParam", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelEventStreamStarted { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.source.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelEventStreamStarted", len)?; + if let Some(v) = self.source.as_ref() { + match v { + zone_kernel_event_stream_started::Source::Syscalls(v) => { + struct_ser.serialize_field("syscalls", v)?; + } + zone_kernel_event_stream_started::Source::NetworkEvents(v) => { + struct_ser.serialize_field("networkEvents", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelEventStreamStarted { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "syscalls", + "network_events", + "networkEvents", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Syscalls, + NetworkEvents, + } + 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 { + "syscalls" => Ok(GeneratedField::Syscalls), + "networkEvents" | "network_events" => Ok(GeneratedField::NetworkEvents), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelEventStreamStarted; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelEventStreamStarted") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut source__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Syscalls => { + if source__.is_some() { + return Err(serde::de::Error::duplicate_field("syscalls")); + } + source__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_event_stream_started::Source::Syscalls) +; + } + GeneratedField::NetworkEvents => { + if source__.is_some() { + return Err(serde::de::Error::duplicate_field("networkEvents")); + } + source__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_event_stream_started::Source::NetworkEvents) +; + } + } + } + Ok(ZoneKernelEventStreamStarted { + source: source__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelEventStreamStarted", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelEventStreamStop { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelEventStreamStop", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelEventStreamStop { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + 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, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelEventStreamStop; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelEventStreamStop") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(ZoneKernelEventStreamStop { + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelEventStreamStop", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelEventStreamUpdate { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.source.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelEventStreamUpdate", len)?; + if let Some(v) = self.source.as_ref() { + match v { + zone_kernel_event_stream_update::Source::Syscalls(v) => { + struct_ser.serialize_field("syscalls", v)?; + } + zone_kernel_event_stream_update::Source::NetworkEvents(v) => { + struct_ser.serialize_field("networkEvents", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelEventStreamUpdate { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "syscalls", + "network_events", + "networkEvents", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Syscalls, + NetworkEvents, + } + 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 { + "syscalls" => Ok(GeneratedField::Syscalls), + "networkEvents" | "network_events" => Ok(GeneratedField::NetworkEvents), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelEventStreamUpdate; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelEventStreamUpdate") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut source__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Syscalls => { + if source__.is_some() { + return Err(serde::de::Error::duplicate_field("syscalls")); + } + source__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_event_stream_update::Source::Syscalls) +; + } + GeneratedField::NetworkEvents => { + if source__.is_some() { + return Err(serde::de::Error::duplicate_field("networkEvents")); + } + source__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_event_stream_update::Source::NetworkEvents) +; + } + } + } + Ok(ZoneKernelEventStreamUpdate { + source: source__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelEventStreamUpdate", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelFdInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.fd.is_some() { + len += 1; + } + if self.inode != 0 { + len += 1; + } + if self.fd_type != 0 { + len += 1; + } + if self.info.is_some() { + len += 1; + } + if self.open_flags != 0 { + len += 1; + } + if self.state_flags != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelFdInfo", len)?; + if let Some(v) = self.fd.as_ref() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("fd", ToString::to_string(&v).as_str())?; + } + if self.inode != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("inode", ToString::to_string(&self.inode).as_str())?; + } + if self.fd_type != 0 { + let v = ZoneKernelFdType::try_from(self.fd_type) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fd_type)))?; + struct_ser.serialize_field("fdType", &v)?; + } + if let Some(v) = self.info.as_ref() { + struct_ser.serialize_field("info", v)?; + } + if self.open_flags != 0 { + struct_ser.serialize_field("openFlags", &self.open_flags)?; + } + if self.state_flags != 0 { + struct_ser.serialize_field("stateFlags", &self.state_flags)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelFdInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "fd", + "inode", + "fd_type", + "fdType", + "info", + "open_flags", + "openFlags", + "state_flags", + "stateFlags", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Fd, + Inode, + FdType, + Info, + OpenFlags, + StateFlags, + } + 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 { + "fd" => Ok(GeneratedField::Fd), + "inode" => Ok(GeneratedField::Inode), + "fdType" | "fd_type" => Ok(GeneratedField::FdType), + "info" => Ok(GeneratedField::Info), + "openFlags" | "open_flags" => Ok(GeneratedField::OpenFlags), + "stateFlags" | "state_flags" => Ok(GeneratedField::StateFlags), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelFdInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelFdInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut fd__ = None; + let mut inode__ = None; + let mut fd_type__ = None; + let mut info__ = None; + let mut open_flags__ = None; + let mut state_flags__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Fd => { + if fd__.is_some() { + return Err(serde::de::Error::duplicate_field("fd")); + } + fd__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::Inode => { + if inode__.is_some() { + return Err(serde::de::Error::duplicate_field("inode")); + } + inode__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::FdType => { + if fd_type__.is_some() { + return Err(serde::de::Error::duplicate_field("fdType")); + } + fd_type__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Info => { + if info__.is_some() { + return Err(serde::de::Error::duplicate_field("info")); + } + info__ = map_.next_value()?; + } + GeneratedField::OpenFlags => { + if open_flags__.is_some() { + return Err(serde::de::Error::duplicate_field("openFlags")); + } + open_flags__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::StateFlags => { + if state_flags__.is_some() { + return Err(serde::de::Error::duplicate_field("stateFlags")); + } + state_flags__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(ZoneKernelFdInfo { + fd: fd__, + inode: inode__.unwrap_or_default(), + fd_type: fd_type__.unwrap_or_default(), + info: info__, + open_flags: open_flags__.unwrap_or_default(), + state_flags: state_flags__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelFdInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelFdInfoData { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.info_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelFdInfoData", len)?; + if let Some(v) = self.info_type.as_ref() { + match v { + zone_kernel_fd_info_data::InfoType::Ipv4Socket(v) => { + struct_ser.serialize_field("ipv4Socket", v)?; + } + zone_kernel_fd_info_data::InfoType::Ipv6Socket(v) => { + struct_ser.serialize_field("ipv6Socket", v)?; + } + zone_kernel_fd_info_data::InfoType::Ipv4ServerSocket(v) => { + struct_ser.serialize_field("ipv4ServerSocket", v)?; + } + zone_kernel_fd_info_data::InfoType::Ipv6ServerSocket(v) => { + struct_ser.serialize_field("ipv6ServerSocket", v)?; + } + zone_kernel_fd_info_data::InfoType::UnixSocket(v) => { + struct_ser.serialize_field("unixSocket", v)?; + } + zone_kernel_fd_info_data::InfoType::RegularFile(v) => { + struct_ser.serialize_field("regularFile", v)?; + } + zone_kernel_fd_info_data::InfoType::FileName(v) => { + struct_ser.serialize_field("fileName", v)?; + } + zone_kernel_fd_info_data::InfoType::Pidfd(v) => { + struct_ser.serialize_field("pidfd", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelFdInfoData { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ipv4_socket", + "ipv4Socket", + "ipv6_socket", + "ipv6Socket", + "ipv4_server_socket", + "ipv4ServerSocket", + "ipv6_server_socket", + "ipv6ServerSocket", + "unix_socket", + "unixSocket", + "regular_file", + "regularFile", + "file_name", + "fileName", + "pidfd", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Ipv4Socket, + Ipv6Socket, + Ipv4ServerSocket, + Ipv6ServerSocket, + UnixSocket, + RegularFile, + FileName, + Pidfd, + } + 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 { + "ipv4Socket" | "ipv4_socket" => Ok(GeneratedField::Ipv4Socket), + "ipv6Socket" | "ipv6_socket" => Ok(GeneratedField::Ipv6Socket), + "ipv4ServerSocket" | "ipv4_server_socket" => Ok(GeneratedField::Ipv4ServerSocket), + "ipv6ServerSocket" | "ipv6_server_socket" => Ok(GeneratedField::Ipv6ServerSocket), + "unixSocket" | "unix_socket" => Ok(GeneratedField::UnixSocket), + "regularFile" | "regular_file" => Ok(GeneratedField::RegularFile), + "fileName" | "file_name" => Ok(GeneratedField::FileName), + "pidfd" => Ok(GeneratedField::Pidfd), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelFdInfoData; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelFdInfoData") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut info_type__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Ipv4Socket => { + if info_type__.is_some() { + return Err(serde::de::Error::duplicate_field("ipv4Socket")); + } + info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Ipv4Socket) +; + } + GeneratedField::Ipv6Socket => { + if info_type__.is_some() { + return Err(serde::de::Error::duplicate_field("ipv6Socket")); + } + info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Ipv6Socket) +; + } + GeneratedField::Ipv4ServerSocket => { + if info_type__.is_some() { + return Err(serde::de::Error::duplicate_field("ipv4ServerSocket")); + } + info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Ipv4ServerSocket) +; + } + GeneratedField::Ipv6ServerSocket => { + if info_type__.is_some() { + return Err(serde::de::Error::duplicate_field("ipv6ServerSocket")); + } + info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Ipv6ServerSocket) +; + } + GeneratedField::UnixSocket => { + if info_type__.is_some() { + return Err(serde::de::Error::duplicate_field("unixSocket")); + } + info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::UnixSocket) +; + } + GeneratedField::RegularFile => { + if info_type__.is_some() { + return Err(serde::de::Error::duplicate_field("regularFile")); + } + info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::RegularFile) +; + } + GeneratedField::FileName => { + if info_type__.is_some() { + return Err(serde::de::Error::duplicate_field("fileName")); + } + info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::FileName); + } + GeneratedField::Pidfd => { + if info_type__.is_some() { + return Err(serde::de::Error::duplicate_field("pidfd")); + } + info_type__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_fd_info_data::InfoType::Pidfd) +; + } + } + } + Ok(ZoneKernelFdInfoData { + info_type: info_type__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelFdInfoData", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelFdType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "ZONE_KERNEL_FD_TYPE_UNKNOWN", + Self::File => "ZONE_KERNEL_FD_TYPE_FILE", + Self::Directory => "ZONE_KERNEL_FD_TYPE_DIRECTORY", + Self::Ipv4Sock => "ZONE_KERNEL_FD_TYPE_IPV4_SOCK", + Self::Ipv6Sock => "ZONE_KERNEL_FD_TYPE_IPV6_SOCK", + Self::Ipv4Servsock => "ZONE_KERNEL_FD_TYPE_IPV4_SERVSOCK", + Self::Ipv6Servsock => "ZONE_KERNEL_FD_TYPE_IPV6_SERVSOCK", + Self::Fifo => "ZONE_KERNEL_FD_TYPE_FIFO", + Self::UnixSock => "ZONE_KERNEL_FD_TYPE_UNIX_SOCK", + Self::Event => "ZONE_KERNEL_FD_TYPE_EVENT", + Self::Unsupported => "ZONE_KERNEL_FD_TYPE_UNSUPPORTED", + Self::Signalfd => "ZONE_KERNEL_FD_TYPE_SIGNALFD", + Self::Eventpoll => "ZONE_KERNEL_FD_TYPE_EVENTPOLL", + Self::Inotify => "ZONE_KERNEL_FD_TYPE_INOTIFY", + Self::Timerfd => "ZONE_KERNEL_FD_TYPE_TIMERFD", + Self::Netlink => "ZONE_KERNEL_FD_TYPE_NETLINK", + Self::FileV2 => "ZONE_KERNEL_FD_TYPE_FILE_V2", + Self::Bpf => "ZONE_KERNEL_FD_TYPE_BPF", + Self::Userfaultfd => "ZONE_KERNEL_FD_TYPE_USERFAULTFD", + Self::Iouring => "ZONE_KERNEL_FD_TYPE_IOURING", + Self::Memfd => "ZONE_KERNEL_FD_TYPE_MEMFD", + Self::Pidfd => "ZONE_KERNEL_FD_TYPE_PIDFD", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelFdType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_KERNEL_FD_TYPE_UNKNOWN", + "ZONE_KERNEL_FD_TYPE_FILE", + "ZONE_KERNEL_FD_TYPE_DIRECTORY", + "ZONE_KERNEL_FD_TYPE_IPV4_SOCK", + "ZONE_KERNEL_FD_TYPE_IPV6_SOCK", + "ZONE_KERNEL_FD_TYPE_IPV4_SERVSOCK", + "ZONE_KERNEL_FD_TYPE_IPV6_SERVSOCK", + "ZONE_KERNEL_FD_TYPE_FIFO", + "ZONE_KERNEL_FD_TYPE_UNIX_SOCK", + "ZONE_KERNEL_FD_TYPE_EVENT", + "ZONE_KERNEL_FD_TYPE_UNSUPPORTED", + "ZONE_KERNEL_FD_TYPE_SIGNALFD", + "ZONE_KERNEL_FD_TYPE_EVENTPOLL", + "ZONE_KERNEL_FD_TYPE_INOTIFY", + "ZONE_KERNEL_FD_TYPE_TIMERFD", + "ZONE_KERNEL_FD_TYPE_NETLINK", + "ZONE_KERNEL_FD_TYPE_FILE_V2", + "ZONE_KERNEL_FD_TYPE_BPF", + "ZONE_KERNEL_FD_TYPE_USERFAULTFD", + "ZONE_KERNEL_FD_TYPE_IOURING", + "ZONE_KERNEL_FD_TYPE_MEMFD", + "ZONE_KERNEL_FD_TYPE_PIDFD", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelFdType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_KERNEL_FD_TYPE_UNKNOWN" => Ok(ZoneKernelFdType::Unknown), + "ZONE_KERNEL_FD_TYPE_FILE" => Ok(ZoneKernelFdType::File), + "ZONE_KERNEL_FD_TYPE_DIRECTORY" => Ok(ZoneKernelFdType::Directory), + "ZONE_KERNEL_FD_TYPE_IPV4_SOCK" => Ok(ZoneKernelFdType::Ipv4Sock), + "ZONE_KERNEL_FD_TYPE_IPV6_SOCK" => Ok(ZoneKernelFdType::Ipv6Sock), + "ZONE_KERNEL_FD_TYPE_IPV4_SERVSOCK" => Ok(ZoneKernelFdType::Ipv4Servsock), + "ZONE_KERNEL_FD_TYPE_IPV6_SERVSOCK" => Ok(ZoneKernelFdType::Ipv6Servsock), + "ZONE_KERNEL_FD_TYPE_FIFO" => Ok(ZoneKernelFdType::Fifo), + "ZONE_KERNEL_FD_TYPE_UNIX_SOCK" => Ok(ZoneKernelFdType::UnixSock), + "ZONE_KERNEL_FD_TYPE_EVENT" => Ok(ZoneKernelFdType::Event), + "ZONE_KERNEL_FD_TYPE_UNSUPPORTED" => Ok(ZoneKernelFdType::Unsupported), + "ZONE_KERNEL_FD_TYPE_SIGNALFD" => Ok(ZoneKernelFdType::Signalfd), + "ZONE_KERNEL_FD_TYPE_EVENTPOLL" => Ok(ZoneKernelFdType::Eventpoll), + "ZONE_KERNEL_FD_TYPE_INOTIFY" => Ok(ZoneKernelFdType::Inotify), + "ZONE_KERNEL_FD_TYPE_TIMERFD" => Ok(ZoneKernelFdType::Timerfd), + "ZONE_KERNEL_FD_TYPE_NETLINK" => Ok(ZoneKernelFdType::Netlink), + "ZONE_KERNEL_FD_TYPE_FILE_V2" => Ok(ZoneKernelFdType::FileV2), + "ZONE_KERNEL_FD_TYPE_BPF" => Ok(ZoneKernelFdType::Bpf), + "ZONE_KERNEL_FD_TYPE_USERFAULTFD" => Ok(ZoneKernelFdType::Userfaultfd), + "ZONE_KERNEL_FD_TYPE_IOURING" => Ok(ZoneKernelFdType::Iouring), + "ZONE_KERNEL_FD_TYPE_MEMFD" => Ok(ZoneKernelFdType::Memfd), + "ZONE_KERNEL_FD_TYPE_PIDFD" => Ok(ZoneKernelFdType::Pidfd), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelIpProtocol { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "ZONE_KERNEL_IP_PROTOCOL_UNKNOWN", + Self::Na => "ZONE_KERNEL_IP_PROTOCOL_NA", + Self::Tcp => "ZONE_KERNEL_IP_PROTOCOL_TCP", + Self::Udp => "ZONE_KERNEL_IP_PROTOCOL_UDP", + Self::Icmp => "ZONE_KERNEL_IP_PROTOCOL_ICMP", + Self::Raw => "ZONE_KERNEL_IP_PROTOCOL_RAW", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelIpProtocol { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_KERNEL_IP_PROTOCOL_UNKNOWN", + "ZONE_KERNEL_IP_PROTOCOL_NA", + "ZONE_KERNEL_IP_PROTOCOL_TCP", + "ZONE_KERNEL_IP_PROTOCOL_UDP", + "ZONE_KERNEL_IP_PROTOCOL_ICMP", + "ZONE_KERNEL_IP_PROTOCOL_RAW", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelIpProtocol; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_KERNEL_IP_PROTOCOL_UNKNOWN" => Ok(ZoneKernelIpProtocol::Unknown), + "ZONE_KERNEL_IP_PROTOCOL_NA" => Ok(ZoneKernelIpProtocol::Na), + "ZONE_KERNEL_IP_PROTOCOL_TCP" => Ok(ZoneKernelIpProtocol::Tcp), + "ZONE_KERNEL_IP_PROTOCOL_UDP" => Ok(ZoneKernelIpProtocol::Udp), + "ZONE_KERNEL_IP_PROTOCOL_ICMP" => Ok(ZoneKernelIpProtocol::Icmp), + "ZONE_KERNEL_IP_PROTOCOL_RAW" => Ok(ZoneKernelIpProtocol::Raw), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelIpv4ServerSocketInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.local_ip.is_empty() { + len += 1; + } + if self.local_port != 0 { + len += 1; + } + if self.protocol != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelIpv4ServerSocketInfo", len)?; + if !self.local_ip.is_empty() { + struct_ser.serialize_field("localIp", &self.local_ip)?; + } + if self.local_port != 0 { + struct_ser.serialize_field("localPort", &self.local_port)?; + } + if self.protocol != 0 { + let v = ZoneKernelIpProtocol::try_from(self.protocol) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.protocol)))?; + struct_ser.serialize_field("protocol", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelIpv4ServerSocketInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "local_ip", + "localIp", + "local_port", + "localPort", + "protocol", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + LocalIp, + LocalPort, + Protocol, + } + 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 { + "localIp" | "local_ip" => Ok(GeneratedField::LocalIp), + "localPort" | "local_port" => Ok(GeneratedField::LocalPort), + "protocol" => Ok(GeneratedField::Protocol), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelIpv4ServerSocketInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelIpv4ServerSocketInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut local_ip__ = None; + let mut local_port__ = None; + let mut protocol__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::LocalIp => { + if local_ip__.is_some() { + return Err(serde::de::Error::duplicate_field("localIp")); + } + local_ip__ = Some(map_.next_value()?); + } + GeneratedField::LocalPort => { + if local_port__.is_some() { + return Err(serde::de::Error::duplicate_field("localPort")); + } + local_port__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Protocol => { + if protocol__.is_some() { + return Err(serde::de::Error::duplicate_field("protocol")); + } + protocol__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(ZoneKernelIpv4ServerSocketInfo { + local_ip: local_ip__.unwrap_or_default(), + local_port: local_port__.unwrap_or_default(), + protocol: protocol__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelIpv4ServerSocketInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelIpv4SocketInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.source_ip.is_empty() { + len += 1; + } + if !self.dest_ip.is_empty() { + len += 1; + } + if self.source_port != 0 { + len += 1; + } + if self.dest_port != 0 { + len += 1; + } + if self.protocol != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelIpv4SocketInfo", len)?; + if !self.source_ip.is_empty() { + struct_ser.serialize_field("sourceIp", &self.source_ip)?; + } + if !self.dest_ip.is_empty() { + struct_ser.serialize_field("destIp", &self.dest_ip)?; + } + if self.source_port != 0 { + struct_ser.serialize_field("sourcePort", &self.source_port)?; + } + if self.dest_port != 0 { + struct_ser.serialize_field("destPort", &self.dest_port)?; + } + if self.protocol != 0 { + let v = ZoneKernelIpProtocol::try_from(self.protocol) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.protocol)))?; + struct_ser.serialize_field("protocol", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelIpv4SocketInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "source_ip", + "sourceIp", + "dest_ip", + "destIp", + "source_port", + "sourcePort", + "dest_port", + "destPort", + "protocol", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SourceIp, + DestIp, + SourcePort, + DestPort, + Protocol, + } + 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 { + "sourceIp" | "source_ip" => Ok(GeneratedField::SourceIp), + "destIp" | "dest_ip" => Ok(GeneratedField::DestIp), + "sourcePort" | "source_port" => Ok(GeneratedField::SourcePort), + "destPort" | "dest_port" => Ok(GeneratedField::DestPort), + "protocol" => Ok(GeneratedField::Protocol), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelIpv4SocketInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelIpv4SocketInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut source_ip__ = None; + let mut dest_ip__ = None; + let mut source_port__ = None; + let mut dest_port__ = None; + let mut protocol__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::SourceIp => { + if source_ip__.is_some() { + return Err(serde::de::Error::duplicate_field("sourceIp")); + } + source_ip__ = Some(map_.next_value()?); + } + GeneratedField::DestIp => { + if dest_ip__.is_some() { + return Err(serde::de::Error::duplicate_field("destIp")); + } + dest_ip__ = Some(map_.next_value()?); + } + GeneratedField::SourcePort => { + if source_port__.is_some() { + return Err(serde::de::Error::duplicate_field("sourcePort")); + } + source_port__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::DestPort => { + if dest_port__.is_some() { + return Err(serde::de::Error::duplicate_field("destPort")); + } + dest_port__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Protocol => { + if protocol__.is_some() { + return Err(serde::de::Error::duplicate_field("protocol")); + } + protocol__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(ZoneKernelIpv4SocketInfo { + source_ip: source_ip__.unwrap_or_default(), + dest_ip: dest_ip__.unwrap_or_default(), + source_port: source_port__.unwrap_or_default(), + dest_port: dest_port__.unwrap_or_default(), + protocol: protocol__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelIpv4SocketInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelIpv6ServerSocketInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.local_ip.is_empty() { + len += 1; + } + if self.local_port != 0 { + len += 1; + } + if self.protocol != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelIpv6ServerSocketInfo", len)?; + if !self.local_ip.is_empty() { + struct_ser.serialize_field("localIp", &self.local_ip)?; + } + if self.local_port != 0 { + struct_ser.serialize_field("localPort", &self.local_port)?; + } + if self.protocol != 0 { + let v = ZoneKernelIpProtocol::try_from(self.protocol) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.protocol)))?; + struct_ser.serialize_field("protocol", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelIpv6ServerSocketInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "local_ip", + "localIp", + "local_port", + "localPort", + "protocol", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + LocalIp, + LocalPort, + Protocol, + } + 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 { + "localIp" | "local_ip" => Ok(GeneratedField::LocalIp), + "localPort" | "local_port" => Ok(GeneratedField::LocalPort), + "protocol" => Ok(GeneratedField::Protocol), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelIpv6ServerSocketInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelIpv6ServerSocketInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut local_ip__ = None; + let mut local_port__ = None; + let mut protocol__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::LocalIp => { + if local_ip__.is_some() { + return Err(serde::de::Error::duplicate_field("localIp")); + } + local_ip__ = Some(map_.next_value()?); + } + GeneratedField::LocalPort => { + if local_port__.is_some() { + return Err(serde::de::Error::duplicate_field("localPort")); + } + local_port__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Protocol => { + if protocol__.is_some() { + return Err(serde::de::Error::duplicate_field("protocol")); + } + protocol__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(ZoneKernelIpv6ServerSocketInfo { + local_ip: local_ip__.unwrap_or_default(), + local_port: local_port__.unwrap_or_default(), + protocol: protocol__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelIpv6ServerSocketInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelIpv6SocketInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.source_ip.is_empty() { + len += 1; + } + if !self.dest_ip.is_empty() { + len += 1; + } + if self.source_port != 0 { + len += 1; + } + if self.dest_port != 0 { + len += 1; + } + if self.protocol != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelIpv6SocketInfo", len)?; + if !self.source_ip.is_empty() { + struct_ser.serialize_field("sourceIp", &self.source_ip)?; + } + if !self.dest_ip.is_empty() { + struct_ser.serialize_field("destIp", &self.dest_ip)?; + } + if self.source_port != 0 { + struct_ser.serialize_field("sourcePort", &self.source_port)?; + } + if self.dest_port != 0 { + struct_ser.serialize_field("destPort", &self.dest_port)?; + } + if self.protocol != 0 { + let v = ZoneKernelIpProtocol::try_from(self.protocol) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.protocol)))?; + struct_ser.serialize_field("protocol", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelIpv6SocketInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "source_ip", + "sourceIp", + "dest_ip", + "destIp", + "source_port", + "sourcePort", + "dest_port", + "destPort", + "protocol", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SourceIp, + DestIp, + SourcePort, + DestPort, + Protocol, + } + 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 { + "sourceIp" | "source_ip" => Ok(GeneratedField::SourceIp), + "destIp" | "dest_ip" => Ok(GeneratedField::DestIp), + "sourcePort" | "source_port" => Ok(GeneratedField::SourcePort), + "destPort" | "dest_port" => Ok(GeneratedField::DestPort), + "protocol" => Ok(GeneratedField::Protocol), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelIpv6SocketInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelIpv6SocketInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut source_ip__ = None; + let mut dest_ip__ = None; + let mut source_port__ = None; + let mut dest_port__ = None; + let mut protocol__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::SourceIp => { + if source_ip__.is_some() { + return Err(serde::de::Error::duplicate_field("sourceIp")); + } + source_ip__ = Some(map_.next_value()?); + } + GeneratedField::DestIp => { + if dest_ip__.is_some() { + return Err(serde::de::Error::duplicate_field("destIp")); + } + dest_ip__ = Some(map_.next_value()?); + } + GeneratedField::SourcePort => { + if source_port__.is_some() { + return Err(serde::de::Error::duplicate_field("sourcePort")); + } + source_port__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::DestPort => { + if dest_port__.is_some() { + return Err(serde::de::Error::duplicate_field("destPort")); + } + dest_port__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Protocol => { + if protocol__.is_some() { + return Err(serde::de::Error::duplicate_field("protocol")); + } + protocol__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(ZoneKernelIpv6SocketInfo { + source_ip: source_ip__.unwrap_or_default(), + dest_ip: dest_ip__.unwrap_or_default(), + source_port: source_port__.unwrap_or_default(), + dest_port: dest_port__.unwrap_or_default(), + protocol: protocol__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelIpv6SocketInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelNetworkDirection { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unspecified => "ZONE_KERNEL_NETWORK_DIRECTION_UNSPECIFIED", + Self::Outbound => "ZONE_KERNEL_NETWORK_DIRECTION_OUTBOUND", + Self::Inbound => "ZONE_KERNEL_NETWORK_DIRECTION_INBOUND", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelNetworkDirection { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_KERNEL_NETWORK_DIRECTION_UNSPECIFIED", + "ZONE_KERNEL_NETWORK_DIRECTION_OUTBOUND", + "ZONE_KERNEL_NETWORK_DIRECTION_INBOUND", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelNetworkDirection; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_KERNEL_NETWORK_DIRECTION_UNSPECIFIED" => Ok(ZoneKernelNetworkDirection::Unspecified), + "ZONE_KERNEL_NETWORK_DIRECTION_OUTBOUND" => Ok(ZoneKernelNetworkDirection::Outbound), + "ZONE_KERNEL_NETWORK_DIRECTION_INBOUND" => Ok(ZoneKernelNetworkDirection::Inbound), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelNetworkEvent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.timestamp != 0 { + len += 1; + } + if self.pid != 0 { + len += 1; + } + if !self.comm.is_empty() { + len += 1; + } + if self.event.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelNetworkEvent", len)?; + if self.timestamp != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?; + } + if self.pid != 0 { + struct_ser.serialize_field("pid", &self.pid)?; + } + if !self.comm.is_empty() { + struct_ser.serialize_field("comm", &self.comm)?; + } + if let Some(v) = self.event.as_ref() { + match v { + zone_kernel_network_event::Event::TcpConnection(v) => { + struct_ser.serialize_field("tcpConnection", v)?; + } + zone_kernel_network_event::Event::UdpFlow(v) => { + struct_ser.serialize_field("udpFlow", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelNetworkEvent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "timestamp", + "pid", + "comm", + "tcp_connection", + "tcpConnection", + "udp_flow", + "udpFlow", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Timestamp, + Pid, + Comm, + TcpConnection, + UdpFlow, + } + 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 { + "timestamp" => Ok(GeneratedField::Timestamp), + "pid" => Ok(GeneratedField::Pid), + "comm" => Ok(GeneratedField::Comm), + "tcpConnection" | "tcp_connection" => Ok(GeneratedField::TcpConnection), + "udpFlow" | "udp_flow" => Ok(GeneratedField::UdpFlow), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelNetworkEvent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelNetworkEvent") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut timestamp__ = None; + let mut pid__ = None; + let mut comm__ = None; + let mut event__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Timestamp => { + if timestamp__.is_some() { + return Err(serde::de::Error::duplicate_field("timestamp")); + } + timestamp__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Pid => { + if pid__.is_some() { + return Err(serde::de::Error::duplicate_field("pid")); + } + pid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Comm => { + if comm__.is_some() { + return Err(serde::de::Error::duplicate_field("comm")); + } + comm__ = Some(map_.next_value()?); + } + GeneratedField::TcpConnection => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("tcpConnection")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_network_event::Event::TcpConnection) +; + } + GeneratedField::UdpFlow => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("udpFlow")); + } + event__ = map_.next_value::<::std::option::Option<_>>()?.map(zone_kernel_network_event::Event::UdpFlow) +; + } + } + } + Ok(ZoneKernelNetworkEvent { + timestamp: timestamp__.unwrap_or_default(), + pid: pid__.unwrap_or_default(), + comm: comm__.unwrap_or_default(), + event: event__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelNetworkEvent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelNetworkEvents { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if !self.events.is_empty() { + len += 1; + } + if self.dropped != 0 { + len += 1; + } + if self.skipped_batches != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelNetworkEvents", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.events.is_empty() { + struct_ser.serialize_field("events", &self.events)?; + } + if self.dropped != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("dropped", ToString::to_string(&self.dropped).as_str())?; + } + if self.skipped_batches != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("skippedBatches", ToString::to_string(&self.skipped_batches).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelNetworkEvents { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "events", + "dropped", + "skipped_batches", + "skippedBatches", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + Events, + Dropped, + SkippedBatches, + } + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "events" => Ok(GeneratedField::Events), + "dropped" => Ok(GeneratedField::Dropped), + "skippedBatches" | "skipped_batches" => Ok(GeneratedField::SkippedBatches), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelNetworkEvents; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelNetworkEvents") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut events__ = None; + let mut dropped__ = None; + let mut skipped_batches__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Events => { + if events__.is_some() { + return Err(serde::de::Error::duplicate_field("events")); + } + events__ = Some(map_.next_value()?); + } + GeneratedField::Dropped => { + if dropped__.is_some() { + return Err(serde::de::Error::duplicate_field("dropped")); + } + dropped__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::SkippedBatches => { + if skipped_batches__.is_some() { + return Err(serde::de::Error::duplicate_field("skippedBatches")); + } + skipped_batches__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(ZoneKernelNetworkEvents { + zone_id: zone_id__.unwrap_or_default(), + events: events__.unwrap_or_default(), + dropped: dropped__.unwrap_or_default(), + skipped_batches: skipped_batches__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelNetworkEvents", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelNetworkProtocol { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unspecified => "ZONE_KERNEL_NETWORK_PROTOCOL_UNSPECIFIED", + Self::Tcp => "ZONE_KERNEL_NETWORK_PROTOCOL_TCP", + Self::Udp => "ZONE_KERNEL_NETWORK_PROTOCOL_UDP", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelNetworkProtocol { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_KERNEL_NETWORK_PROTOCOL_UNSPECIFIED", + "ZONE_KERNEL_NETWORK_PROTOCOL_TCP", + "ZONE_KERNEL_NETWORK_PROTOCOL_UDP", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelNetworkProtocol; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_KERNEL_NETWORK_PROTOCOL_UNSPECIFIED" => Ok(ZoneKernelNetworkProtocol::Unspecified), + "ZONE_KERNEL_NETWORK_PROTOCOL_TCP" => Ok(ZoneKernelNetworkProtocol::Tcp), + "ZONE_KERNEL_NETWORK_PROTOCOL_UDP" => Ok(ZoneKernelNetworkProtocol::Udp), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelNetworkSource { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.protocols.is_empty() { + len += 1; + } + if self.direction != 0 { + len += 1; + } + if self.pid.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelNetworkSource", len)?; + if !self.protocols.is_empty() { + let v = self.protocols.iter().cloned().map(|v| { + ZoneKernelNetworkProtocol::try_from(v) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v))) + }).collect::, _>>()?; + struct_ser.serialize_field("protocols", &v)?; + } + if self.direction != 0 { + let v = ZoneKernelNetworkDirection::try_from(self.direction) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?; + struct_ser.serialize_field("direction", &v)?; + } + if let Some(v) = self.pid.as_ref() { + struct_ser.serialize_field("pid", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelNetworkSource { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "protocols", + "direction", + "pid", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Protocols, + Direction, + Pid, + } + 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 { + "protocols" => Ok(GeneratedField::Protocols), + "direction" => Ok(GeneratedField::Direction), + "pid" => Ok(GeneratedField::Pid), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelNetworkSource; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelNetworkSource") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut protocols__ = None; + let mut direction__ = None; + let mut pid__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Protocols => { + if protocols__.is_some() { + return Err(serde::de::Error::duplicate_field("protocols")); + } + protocols__ = Some(map_.next_value::>()?.into_iter().map(|x| x as i32).collect()); + } + GeneratedField::Direction => { + if direction__.is_some() { + return Err(serde::de::Error::duplicate_field("direction")); + } + direction__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Pid => { + if pid__.is_some() { + return Err(serde::de::Error::duplicate_field("pid")); + } + pid__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + } + } + Ok(ZoneKernelNetworkSource { + protocols: protocols__.unwrap_or_default(), + direction: direction__.unwrap_or_default(), + pid: pid__, + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelNetworkSource", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelPidFd { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.pid != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelPidFd", len)?; + if self.pid != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("pid", ToString::to_string(&self.pid).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelPidFd { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "pid", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Pid, + } + 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 { + "pid" => Ok(GeneratedField::Pid), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelPidFd; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelPidFd") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut pid__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Pid => { + if pid__.is_some() { + return Err(serde::de::Error::duplicate_field("pid")); + } + pid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(ZoneKernelPidFd { + pid: pid__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelPidFd", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelRegularFileInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.open_flags != 0 { + len += 1; + } + if !self.name.is_empty() { + len += 1; + } + if self.mount_id != 0 { + len += 1; + } + if self.device != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelRegularFileInfo", len)?; + if self.open_flags != 0 { + struct_ser.serialize_field("openFlags", &self.open_flags)?; + } + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if self.mount_id != 0 { + struct_ser.serialize_field("mountId", &self.mount_id)?; + } + if self.device != 0 { + struct_ser.serialize_field("device", &self.device)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelRegularFileInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "open_flags", + "openFlags", + "name", + "mount_id", + "mountId", + "device", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + OpenFlags, + Name, + MountId, + Device, + } + 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 { + "openFlags" | "open_flags" => Ok(GeneratedField::OpenFlags), + "name" => Ok(GeneratedField::Name), + "mountId" | "mount_id" => Ok(GeneratedField::MountId), + "device" => Ok(GeneratedField::Device), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelRegularFileInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelRegularFileInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut open_flags__ = None; + let mut name__ = None; + let mut mount_id__ = None; + let mut device__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::OpenFlags => { + if open_flags__.is_some() { + return Err(serde::de::Error::duplicate_field("openFlags")); + } + open_flags__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map_.next_value()?); + } + GeneratedField::MountId => { + if mount_id__.is_some() { + return Err(serde::de::Error::duplicate_field("mountId")); + } + mount_id__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Device => { + if device__.is_some() { + return Err(serde::de::Error::duplicate_field("device")); + } + device__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(ZoneKernelRegularFileInfo { + open_flags: open_flags__.unwrap_or_default(), + name: name__.unwrap_or_default(), + mount_id: mount_id__.unwrap_or_default(), + device: device__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelRegularFileInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelSyscallEvent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if self.timestamp != 0 { + len += 1; + } + if self.thread_id != 0 { + len += 1; + } + if self.event_length != 0 { + len += 1; + } + if !self.event_name.is_empty() { + len += 1; + } + if !self.event_category.is_empty() { + len += 1; + } + if self.event_flags != 0 { + len += 1; + } + if self.event_type != 0 { + len += 1; + } + if self.cpuid != 0 { + len += 1; + } + if !self.event_params.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelSyscallEvent", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if self.timestamp != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?; + } + if self.thread_id != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("threadId", ToString::to_string(&self.thread_id).as_str())?; + } + if self.event_length != 0 { + struct_ser.serialize_field("eventLength", &self.event_length)?; + } + if !self.event_name.is_empty() { + struct_ser.serialize_field("eventName", &self.event_name)?; + } + if !self.event_category.is_empty() { + struct_ser.serialize_field("eventCategory", &self.event_category)?; + } + if self.event_flags != 0 { + struct_ser.serialize_field("eventFlags", &self.event_flags)?; + } + if self.event_type != 0 { + struct_ser.serialize_field("eventType", &self.event_type)?; + } + if self.cpuid != 0 { + struct_ser.serialize_field("cpuid", &self.cpuid)?; + } + if !self.event_params.is_empty() { + struct_ser.serialize_field("eventParams", &self.event_params)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelSyscallEvent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "timestamp", + "thread_id", + "threadId", + "event_length", + "eventLength", + "event_name", + "eventName", + "event_category", + "eventCategory", + "event_flags", + "eventFlags", + "event_type", + "eventType", + "cpuid", + "event_params", + "eventParams", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + Timestamp, + ThreadId, + EventLength, + EventName, + EventCategory, + EventFlags, + EventType, + Cpuid, + EventParams, + } + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "timestamp" => Ok(GeneratedField::Timestamp), + "threadId" | "thread_id" => Ok(GeneratedField::ThreadId), + "eventLength" | "event_length" => Ok(GeneratedField::EventLength), + "eventName" | "event_name" => Ok(GeneratedField::EventName), + "eventCategory" | "event_category" => Ok(GeneratedField::EventCategory), + "eventFlags" | "event_flags" => Ok(GeneratedField::EventFlags), + "eventType" | "event_type" => Ok(GeneratedField::EventType), + "cpuid" => Ok(GeneratedField::Cpuid), + "eventParams" | "event_params" => Ok(GeneratedField::EventParams), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelSyscallEvent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelSyscallEvent") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut timestamp__ = None; + let mut thread_id__ = None; + let mut event_length__ = None; + let mut event_name__ = None; + let mut event_category__ = None; + let mut event_flags__ = None; + let mut event_type__ = None; + let mut cpuid__ = None; + let mut event_params__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Timestamp => { + if timestamp__.is_some() { + return Err(serde::de::Error::duplicate_field("timestamp")); + } + timestamp__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ThreadId => { + if thread_id__.is_some() { + return Err(serde::de::Error::duplicate_field("threadId")); + } + thread_id__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::EventLength => { + if event_length__.is_some() { + return Err(serde::de::Error::duplicate_field("eventLength")); + } + event_length__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::EventName => { + if event_name__.is_some() { + return Err(serde::de::Error::duplicate_field("eventName")); + } + event_name__ = Some(map_.next_value()?); + } + GeneratedField::EventCategory => { + if event_category__.is_some() { + return Err(serde::de::Error::duplicate_field("eventCategory")); + } + event_category__ = Some(map_.next_value()?); + } + GeneratedField::EventFlags => { + if event_flags__.is_some() { + return Err(serde::de::Error::duplicate_field("eventFlags")); + } + event_flags__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::EventType => { + if event_type__.is_some() { + return Err(serde::de::Error::duplicate_field("eventType")); + } + event_type__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Cpuid => { + if cpuid__.is_some() { + return Err(serde::de::Error::duplicate_field("cpuid")); + } + cpuid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::EventParams => { + if event_params__.is_some() { + return Err(serde::de::Error::duplicate_field("eventParams")); + } + event_params__ = Some(map_.next_value()?); + } + } + } + Ok(ZoneKernelSyscallEvent { + zone_id: zone_id__.unwrap_or_default(), + timestamp: timestamp__.unwrap_or_default(), + thread_id: thread_id__.unwrap_or_default(), + event_length: event_length__.unwrap_or_default(), + event_name: event_name__.unwrap_or_default(), + event_category: event_category__.unwrap_or_default(), + event_flags: event_flags__.unwrap_or_default(), + event_type: event_type__.unwrap_or_default(), + cpuid: cpuid__.unwrap_or_default(), + event_params: event_params__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelSyscallEvent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelSyscallSource { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.enabled_syscalls.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelSyscallSource", len)?; + if !self.enabled_syscalls.is_empty() { + struct_ser.serialize_field("enabledSyscalls", &self.enabled_syscalls)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelSyscallSource { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "enabled_syscalls", + "enabledSyscalls", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EnabledSyscalls, + } + 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 { + "enabledSyscalls" | "enabled_syscalls" => Ok(GeneratedField::EnabledSyscalls), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelSyscallSource; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelSyscallSource") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut enabled_syscalls__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::EnabledSyscalls => { + if enabled_syscalls__.is_some() { + return Err(serde::de::Error::duplicate_field("enabledSyscalls")); + } + enabled_syscalls__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(ZoneKernelSyscallSource { + enabled_syscalls: enabled_syscalls__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelSyscallSource", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelTcpConnection { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.local_address.is_empty() { + len += 1; + } + if self.local_port != 0 { + len += 1; + } + if !self.remote_address.is_empty() { + len += 1; + } + if self.remote_port != 0 { + len += 1; + } + if self.latency != 0 { + len += 1; + } + if self.established { + len += 1; + } + if self.direction != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelTcpConnection", len)?; + if !self.local_address.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("localAddress", pbjson::private::base64::encode(&self.local_address).as_str())?; + } + if self.local_port != 0 { + struct_ser.serialize_field("localPort", &self.local_port)?; + } + if !self.remote_address.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("remoteAddress", pbjson::private::base64::encode(&self.remote_address).as_str())?; + } + if self.remote_port != 0 { + struct_ser.serialize_field("remotePort", &self.remote_port)?; + } + if self.latency != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("latency", ToString::to_string(&self.latency).as_str())?; + } + if self.established { + struct_ser.serialize_field("established", &self.established)?; + } + if self.direction != 0 { + let v = ZoneKernelNetworkDirection::try_from(self.direction) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?; + struct_ser.serialize_field("direction", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelTcpConnection { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "local_address", + "localAddress", + "local_port", + "localPort", + "remote_address", + "remoteAddress", + "remote_port", + "remotePort", + "latency", + "established", + "direction", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + LocalAddress, + LocalPort, + RemoteAddress, + RemotePort, + Latency, + Established, + Direction, + } + 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 { + "localAddress" | "local_address" => Ok(GeneratedField::LocalAddress), + "localPort" | "local_port" => Ok(GeneratedField::LocalPort), + "remoteAddress" | "remote_address" => Ok(GeneratedField::RemoteAddress), + "remotePort" | "remote_port" => Ok(GeneratedField::RemotePort), + "latency" => Ok(GeneratedField::Latency), + "established" => Ok(GeneratedField::Established), + "direction" => Ok(GeneratedField::Direction), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelTcpConnection; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelTcpConnection") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut local_address__ = None; + let mut local_port__ = None; + let mut remote_address__ = None; + let mut remote_port__ = None; + let mut latency__ = None; + let mut established__ = None; + let mut direction__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::LocalAddress => { + if local_address__.is_some() { + return Err(serde::de::Error::duplicate_field("localAddress")); + } + local_address__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::LocalPort => { + if local_port__.is_some() { + return Err(serde::de::Error::duplicate_field("localPort")); + } + local_port__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::RemoteAddress => { + if remote_address__.is_some() { + return Err(serde::de::Error::duplicate_field("remoteAddress")); + } + remote_address__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::RemotePort => { + if remote_port__.is_some() { + return Err(serde::de::Error::duplicate_field("remotePort")); + } + remote_port__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Latency => { + if latency__.is_some() { + return Err(serde::de::Error::duplicate_field("latency")); + } + latency__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Established => { + if established__.is_some() { + return Err(serde::de::Error::duplicate_field("established")); + } + established__ = Some(map_.next_value()?); + } + GeneratedField::Direction => { + if direction__.is_some() { + return Err(serde::de::Error::duplicate_field("direction")); + } + direction__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(ZoneKernelTcpConnection { + local_address: local_address__.unwrap_or_default(), + local_port: local_port__.unwrap_or_default(), + remote_address: remote_address__.unwrap_or_default(), + remote_port: remote_port__.unwrap_or_default(), + latency: latency__.unwrap_or_default(), + established: established__.unwrap_or_default(), + direction: direction__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelTcpConnection", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelThreadInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.tid.is_some() { + len += 1; + } + if self.pid.is_some() { + len += 1; + } + if self.ptid.is_some() { + len += 1; + } + if self.sid != 0 { + len += 1; + } + if self.vpgid != 0 { + len += 1; + } + if self.pgid != 0 { + len += 1; + } + if !self.comm.is_empty() { + len += 1; + } + if !self.exe.is_empty() { + len += 1; + } + if !self.exepath.is_empty() { + len += 1; + } + if self.exe_writable { + len += 1; + } + if self.exe_upper_layer { + len += 1; + } + if self.exe_lower_layer { + len += 1; + } + if self.exe_from_memfd { + len += 1; + } + if !self.args.is_empty() { + len += 1; + } + if !self.env.is_empty() { + len += 1; + } + if !self.cwd.is_empty() { + len += 1; + } + if self.fdlimit != 0 { + len += 1; + } + if self.flags != 0 { + len += 1; + } + if self.uid != 0 { + len += 1; + } + if self.gid != 0 { + len += 1; + } + if self.cap_permitted != 0 { + len += 1; + } + if self.cap_effective != 0 { + len += 1; + } + if self.cap_inheritable != 0 { + len += 1; + } + if self.exe_ino != 0 { + len += 1; + } + if self.exe_ino_ctime != 0 { + len += 1; + } + if self.exe_ino_mtime != 0 { + len += 1; + } + if self.exe_ino_ctime_duration_clone_ts != 0 { + len += 1; + } + if self.exe_ino_ctime_duration_pidns_start != 0 { + len += 1; + } + if self.vmsize_kb != 0 { + len += 1; + } + if self.vmrss_kb != 0 { + len += 1; + } + if self.vmswap_kb != 0 { + len += 1; + } + if self.pfmajor != 0 { + len += 1; + } + if self.pfminor != 0 { + len += 1; + } + if self.vtid.is_some() { + len += 1; + } + if self.vpid.is_some() { + len += 1; + } + if self.pidns_init_start_ts != 0 { + len += 1; + } + if !self.cgroups.is_empty() { + len += 1; + } + if !self.root.is_empty() { + len += 1; + } + if self.filtered_out { + len += 1; + } + if !self.fdlist.is_empty() { + len += 1; + } + if self.clone_ts != 0 { + len += 1; + } + if self.tty != 0 { + len += 1; + } + if self.loginuid != 0 { + len += 1; + } + if self.lastexec_ts != 0 { + len += 1; + } + if self.reaper { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelThreadInfo", len)?; + if let Some(v) = self.tid.as_ref() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("tid", ToString::to_string(&v).as_str())?; + } + if let Some(v) = self.pid.as_ref() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("pid", ToString::to_string(&v).as_str())?; + } + if let Some(v) = self.ptid.as_ref() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("ptid", ToString::to_string(&v).as_str())?; + } + if self.sid != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("sid", ToString::to_string(&self.sid).as_str())?; + } + if self.vpgid != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("vpgid", ToString::to_string(&self.vpgid).as_str())?; + } + if self.pgid != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("pgid", ToString::to_string(&self.pgid).as_str())?; + } + if !self.comm.is_empty() { + struct_ser.serialize_field("comm", &self.comm)?; + } + if !self.exe.is_empty() { + struct_ser.serialize_field("exe", &self.exe)?; + } + if !self.exepath.is_empty() { + struct_ser.serialize_field("exepath", &self.exepath)?; + } + if self.exe_writable { + struct_ser.serialize_field("exeWritable", &self.exe_writable)?; + } + if self.exe_upper_layer { + struct_ser.serialize_field("exeUpperLayer", &self.exe_upper_layer)?; + } + if self.exe_lower_layer { + struct_ser.serialize_field("exeLowerLayer", &self.exe_lower_layer)?; + } + if self.exe_from_memfd { + struct_ser.serialize_field("exeFromMemfd", &self.exe_from_memfd)?; + } + if !self.args.is_empty() { + struct_ser.serialize_field("args", &self.args)?; + } + if !self.env.is_empty() { + struct_ser.serialize_field("env", &self.env)?; + } + if !self.cwd.is_empty() { + struct_ser.serialize_field("cwd", &self.cwd)?; + } + if self.fdlimit != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("fdlimit", ToString::to_string(&self.fdlimit).as_str())?; + } + if self.flags != 0 { + struct_ser.serialize_field("flags", &self.flags)?; + } + if self.uid != 0 { + struct_ser.serialize_field("uid", &self.uid)?; + } + if self.gid != 0 { + struct_ser.serialize_field("gid", &self.gid)?; + } + if self.cap_permitted != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("capPermitted", ToString::to_string(&self.cap_permitted).as_str())?; + } + if self.cap_effective != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("capEffective", ToString::to_string(&self.cap_effective).as_str())?; + } + if self.cap_inheritable != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("capInheritable", ToString::to_string(&self.cap_inheritable).as_str())?; + } + if self.exe_ino != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("exeIno", ToString::to_string(&self.exe_ino).as_str())?; + } + if self.exe_ino_ctime != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("exeInoCtime", ToString::to_string(&self.exe_ino_ctime).as_str())?; + } + if self.exe_ino_mtime != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("exeInoMtime", ToString::to_string(&self.exe_ino_mtime).as_str())?; + } + if self.exe_ino_ctime_duration_clone_ts != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("exeInoCtimeDurationCloneTs", ToString::to_string(&self.exe_ino_ctime_duration_clone_ts).as_str())?; + } + if self.exe_ino_ctime_duration_pidns_start != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("exeInoCtimeDurationPidnsStart", ToString::to_string(&self.exe_ino_ctime_duration_pidns_start).as_str())?; + } + if self.vmsize_kb != 0 { + struct_ser.serialize_field("vmsizeKb", &self.vmsize_kb)?; + } + if self.vmrss_kb != 0 { + struct_ser.serialize_field("vmrssKb", &self.vmrss_kb)?; + } + if self.vmswap_kb != 0 { + struct_ser.serialize_field("vmswapKb", &self.vmswap_kb)?; + } + if self.pfmajor != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("pfmajor", ToString::to_string(&self.pfmajor).as_str())?; + } + if self.pfminor != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("pfminor", ToString::to_string(&self.pfminor).as_str())?; + } + if let Some(v) = self.vtid.as_ref() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("vtid", ToString::to_string(&v).as_str())?; + } + if let Some(v) = self.vpid.as_ref() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("vpid", ToString::to_string(&v).as_str())?; + } + if self.pidns_init_start_ts != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("pidnsInitStartTs", ToString::to_string(&self.pidns_init_start_ts).as_str())?; + } + if !self.cgroups.is_empty() { + struct_ser.serialize_field("cgroups", &self.cgroups)?; + } + if !self.root.is_empty() { + struct_ser.serialize_field("root", &self.root)?; + } + if self.filtered_out { + struct_ser.serialize_field("filteredOut", &self.filtered_out)?; + } + if !self.fdlist.is_empty() { + struct_ser.serialize_field("fdlist", &self.fdlist)?; + } + if self.clone_ts != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("cloneTs", ToString::to_string(&self.clone_ts).as_str())?; + } + if self.tty != 0 { + struct_ser.serialize_field("tty", &self.tty)?; + } + if self.loginuid != 0 { + struct_ser.serialize_field("loginuid", &self.loginuid)?; + } + if self.lastexec_ts != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("lastexecTs", ToString::to_string(&self.lastexec_ts).as_str())?; + } + if self.reaper { + struct_ser.serialize_field("reaper", &self.reaper)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelThreadInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "tid", + "pid", + "ptid", + "sid", + "vpgid", + "pgid", + "comm", + "exe", + "exepath", + "exe_writable", + "exeWritable", + "exe_upper_layer", + "exeUpperLayer", + "exe_lower_layer", + "exeLowerLayer", + "exe_from_memfd", + "exeFromMemfd", + "args", + "env", + "cwd", + "fdlimit", + "flags", + "uid", + "gid", + "cap_permitted", + "capPermitted", + "cap_effective", + "capEffective", + "cap_inheritable", + "capInheritable", + "exe_ino", + "exeIno", + "exe_ino_ctime", + "exeInoCtime", + "exe_ino_mtime", + "exeInoMtime", + "exe_ino_ctime_duration_clone_ts", + "exeInoCtimeDurationCloneTs", + "exe_ino_ctime_duration_pidns_start", + "exeInoCtimeDurationPidnsStart", + "vmsize_kb", + "vmsizeKb", + "vmrss_kb", + "vmrssKb", + "vmswap_kb", + "vmswapKb", + "pfmajor", + "pfminor", + "vtid", + "vpid", + "pidns_init_start_ts", + "pidnsInitStartTs", + "cgroups", + "root", + "filtered_out", + "filteredOut", + "fdlist", + "clone_ts", + "cloneTs", + "tty", + "loginuid", + "lastexec_ts", + "lastexecTs", + "reaper", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Tid, + Pid, + Ptid, + Sid, + Vpgid, + Pgid, + Comm, + Exe, + Exepath, + ExeWritable, + ExeUpperLayer, + ExeLowerLayer, + ExeFromMemfd, + Args, + Env, + Cwd, + Fdlimit, + Flags, + Uid, + Gid, + CapPermitted, + CapEffective, + CapInheritable, + ExeIno, + ExeInoCtime, + ExeInoMtime, + ExeInoCtimeDurationCloneTs, + ExeInoCtimeDurationPidnsStart, + VmsizeKb, + VmrssKb, + VmswapKb, + Pfmajor, + Pfminor, + Vtid, + Vpid, + PidnsInitStartTs, + Cgroups, + Root, + FilteredOut, + Fdlist, + CloneTs, + Tty, + Loginuid, + LastexecTs, + Reaper, + } + 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 { + "tid" => Ok(GeneratedField::Tid), + "pid" => Ok(GeneratedField::Pid), + "ptid" => Ok(GeneratedField::Ptid), + "sid" => Ok(GeneratedField::Sid), + "vpgid" => Ok(GeneratedField::Vpgid), + "pgid" => Ok(GeneratedField::Pgid), + "comm" => Ok(GeneratedField::Comm), + "exe" => Ok(GeneratedField::Exe), + "exepath" => Ok(GeneratedField::Exepath), + "exeWritable" | "exe_writable" => Ok(GeneratedField::ExeWritable), + "exeUpperLayer" | "exe_upper_layer" => Ok(GeneratedField::ExeUpperLayer), + "exeLowerLayer" | "exe_lower_layer" => Ok(GeneratedField::ExeLowerLayer), + "exeFromMemfd" | "exe_from_memfd" => Ok(GeneratedField::ExeFromMemfd), + "args" => Ok(GeneratedField::Args), + "env" => Ok(GeneratedField::Env), + "cwd" => Ok(GeneratedField::Cwd), + "fdlimit" => Ok(GeneratedField::Fdlimit), + "flags" => Ok(GeneratedField::Flags), + "uid" => Ok(GeneratedField::Uid), + "gid" => Ok(GeneratedField::Gid), + "capPermitted" | "cap_permitted" => Ok(GeneratedField::CapPermitted), + "capEffective" | "cap_effective" => Ok(GeneratedField::CapEffective), + "capInheritable" | "cap_inheritable" => Ok(GeneratedField::CapInheritable), + "exeIno" | "exe_ino" => Ok(GeneratedField::ExeIno), + "exeInoCtime" | "exe_ino_ctime" => Ok(GeneratedField::ExeInoCtime), + "exeInoMtime" | "exe_ino_mtime" => Ok(GeneratedField::ExeInoMtime), + "exeInoCtimeDurationCloneTs" | "exe_ino_ctime_duration_clone_ts" => Ok(GeneratedField::ExeInoCtimeDurationCloneTs), + "exeInoCtimeDurationPidnsStart" | "exe_ino_ctime_duration_pidns_start" => Ok(GeneratedField::ExeInoCtimeDurationPidnsStart), + "vmsizeKb" | "vmsize_kb" => Ok(GeneratedField::VmsizeKb), + "vmrssKb" | "vmrss_kb" => Ok(GeneratedField::VmrssKb), + "vmswapKb" | "vmswap_kb" => Ok(GeneratedField::VmswapKb), + "pfmajor" => Ok(GeneratedField::Pfmajor), + "pfminor" => Ok(GeneratedField::Pfminor), + "vtid" => Ok(GeneratedField::Vtid), + "vpid" => Ok(GeneratedField::Vpid), + "pidnsInitStartTs" | "pidns_init_start_ts" => Ok(GeneratedField::PidnsInitStartTs), + "cgroups" => Ok(GeneratedField::Cgroups), + "root" => Ok(GeneratedField::Root), + "filteredOut" | "filtered_out" => Ok(GeneratedField::FilteredOut), + "fdlist" => Ok(GeneratedField::Fdlist), + "cloneTs" | "clone_ts" => Ok(GeneratedField::CloneTs), + "tty" => Ok(GeneratedField::Tty), + "loginuid" => Ok(GeneratedField::Loginuid), + "lastexecTs" | "lastexec_ts" => Ok(GeneratedField::LastexecTs), + "reaper" => Ok(GeneratedField::Reaper), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelThreadInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelThreadInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut tid__ = None; + let mut pid__ = None; + let mut ptid__ = None; + let mut sid__ = None; + let mut vpgid__ = None; + let mut pgid__ = None; + let mut comm__ = None; + let mut exe__ = None; + let mut exepath__ = None; + let mut exe_writable__ = None; + let mut exe_upper_layer__ = None; + let mut exe_lower_layer__ = None; + let mut exe_from_memfd__ = None; + let mut args__ = None; + let mut env__ = None; + let mut cwd__ = None; + let mut fdlimit__ = None; + let mut flags__ = None; + let mut uid__ = None; + let mut gid__ = None; + let mut cap_permitted__ = None; + let mut cap_effective__ = None; + let mut cap_inheritable__ = None; + let mut exe_ino__ = None; + let mut exe_ino_ctime__ = None; + let mut exe_ino_mtime__ = None; + let mut exe_ino_ctime_duration_clone_ts__ = None; + let mut exe_ino_ctime_duration_pidns_start__ = None; + let mut vmsize_kb__ = None; + let mut vmrss_kb__ = None; + let mut vmswap_kb__ = None; + let mut pfmajor__ = None; + let mut pfminor__ = None; + let mut vtid__ = None; + let mut vpid__ = None; + let mut pidns_init_start_ts__ = None; + let mut cgroups__ = None; + let mut root__ = None; + let mut filtered_out__ = None; + let mut fdlist__ = None; + let mut clone_ts__ = None; + let mut tty__ = None; + let mut loginuid__ = None; + let mut lastexec_ts__ = None; + let mut reaper__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Tid => { + if tid__.is_some() { + return Err(serde::de::Error::duplicate_field("tid")); + } + tid__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::Pid => { + if pid__.is_some() { + return Err(serde::de::Error::duplicate_field("pid")); + } + pid__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::Ptid => { + if ptid__.is_some() { + return Err(serde::de::Error::duplicate_field("ptid")); + } + ptid__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::Sid => { + if sid__.is_some() { + return Err(serde::de::Error::duplicate_field("sid")); + } + sid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Vpgid => { + if vpgid__.is_some() { + return Err(serde::de::Error::duplicate_field("vpgid")); + } + vpgid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Pgid => { + if pgid__.is_some() { + return Err(serde::de::Error::duplicate_field("pgid")); + } + pgid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Comm => { + if comm__.is_some() { + return Err(serde::de::Error::duplicate_field("comm")); + } + comm__ = Some(map_.next_value()?); + } + GeneratedField::Exe => { + if exe__.is_some() { + return Err(serde::de::Error::duplicate_field("exe")); + } + exe__ = Some(map_.next_value()?); + } + GeneratedField::Exepath => { + if exepath__.is_some() { + return Err(serde::de::Error::duplicate_field("exepath")); + } + exepath__ = Some(map_.next_value()?); + } + GeneratedField::ExeWritable => { + if exe_writable__.is_some() { + return Err(serde::de::Error::duplicate_field("exeWritable")); + } + exe_writable__ = Some(map_.next_value()?); + } + GeneratedField::ExeUpperLayer => { + if exe_upper_layer__.is_some() { + return Err(serde::de::Error::duplicate_field("exeUpperLayer")); + } + exe_upper_layer__ = Some(map_.next_value()?); + } + GeneratedField::ExeLowerLayer => { + if exe_lower_layer__.is_some() { + return Err(serde::de::Error::duplicate_field("exeLowerLayer")); + } + exe_lower_layer__ = Some(map_.next_value()?); + } + GeneratedField::ExeFromMemfd => { + if exe_from_memfd__.is_some() { + return Err(serde::de::Error::duplicate_field("exeFromMemfd")); + } + exe_from_memfd__ = Some(map_.next_value()?); + } + GeneratedField::Args => { + if args__.is_some() { + return Err(serde::de::Error::duplicate_field("args")); + } + args__ = Some(map_.next_value()?); + } + GeneratedField::Env => { + if env__.is_some() { + return Err(serde::de::Error::duplicate_field("env")); + } + env__ = Some(map_.next_value()?); + } + GeneratedField::Cwd => { if cwd__.is_some() { return Err(serde::de::Error::duplicate_field("cwd")); } @@ -17942,222 +29295,1146 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelThreadInfo { Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::ExeInoCtime => { - if exe_ino_ctime__.is_some() { - return Err(serde::de::Error::duplicate_field("exeInoCtime")); + GeneratedField::ExeInoCtime => { + if exe_ino_ctime__.is_some() { + return Err(serde::de::Error::duplicate_field("exeInoCtime")); + } + exe_ino_ctime__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ExeInoMtime => { + if exe_ino_mtime__.is_some() { + return Err(serde::de::Error::duplicate_field("exeInoMtime")); + } + exe_ino_mtime__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ExeInoCtimeDurationCloneTs => { + if exe_ino_ctime_duration_clone_ts__.is_some() { + return Err(serde::de::Error::duplicate_field("exeInoCtimeDurationCloneTs")); + } + exe_ino_ctime_duration_clone_ts__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ExeInoCtimeDurationPidnsStart => { + if exe_ino_ctime_duration_pidns_start__.is_some() { + return Err(serde::de::Error::duplicate_field("exeInoCtimeDurationPidnsStart")); + } + exe_ino_ctime_duration_pidns_start__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::VmsizeKb => { + if vmsize_kb__.is_some() { + return Err(serde::de::Error::duplicate_field("vmsizeKb")); + } + vmsize_kb__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::VmrssKb => { + if vmrss_kb__.is_some() { + return Err(serde::de::Error::duplicate_field("vmrssKb")); + } + vmrss_kb__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::VmswapKb => { + if vmswap_kb__.is_some() { + return Err(serde::de::Error::duplicate_field("vmswapKb")); + } + vmswap_kb__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Pfmajor => { + if pfmajor__.is_some() { + return Err(serde::de::Error::duplicate_field("pfmajor")); + } + pfmajor__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Pfminor => { + if pfminor__.is_some() { + return Err(serde::de::Error::duplicate_field("pfminor")); + } + pfminor__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Vtid => { + if vtid__.is_some() { + return Err(serde::de::Error::duplicate_field("vtid")); + } + vtid__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::Vpid => { + if vpid__.is_some() { + return Err(serde::de::Error::duplicate_field("vpid")); + } + vpid__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::PidnsInitStartTs => { + if pidns_init_start_ts__.is_some() { + return Err(serde::de::Error::duplicate_field("pidnsInitStartTs")); + } + pidns_init_start_ts__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Cgroups => { + if cgroups__.is_some() { + return Err(serde::de::Error::duplicate_field("cgroups")); + } + cgroups__ = Some(map_.next_value()?); + } + GeneratedField::Root => { + if root__.is_some() { + return Err(serde::de::Error::duplicate_field("root")); + } + root__ = Some(map_.next_value()?); + } + GeneratedField::FilteredOut => { + if filtered_out__.is_some() { + return Err(serde::de::Error::duplicate_field("filteredOut")); + } + filtered_out__ = Some(map_.next_value()?); + } + GeneratedField::Fdlist => { + if fdlist__.is_some() { + return Err(serde::de::Error::duplicate_field("fdlist")); + } + fdlist__ = Some( + map_.next_value::, _>>()? + .into_iter().map(|(k,v)| (k.0, v)).collect() + ); + } + GeneratedField::CloneTs => { + if clone_ts__.is_some() { + return Err(serde::de::Error::duplicate_field("cloneTs")); + } + clone_ts__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Tty => { + if tty__.is_some() { + return Err(serde::de::Error::duplicate_field("tty")); + } + tty__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Loginuid => { + if loginuid__.is_some() { + return Err(serde::de::Error::duplicate_field("loginuid")); + } + loginuid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::LastexecTs => { + if lastexec_ts__.is_some() { + return Err(serde::de::Error::duplicate_field("lastexecTs")); + } + lastexec_ts__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Reaper => { + if reaper__.is_some() { + return Err(serde::de::Error::duplicate_field("reaper")); + } + reaper__ = Some(map_.next_value()?); + } + } + } + Ok(ZoneKernelThreadInfo { + tid: tid__, + pid: pid__, + ptid: ptid__, + sid: sid__.unwrap_or_default(), + vpgid: vpgid__.unwrap_or_default(), + pgid: pgid__.unwrap_or_default(), + comm: comm__.unwrap_or_default(), + exe: exe__.unwrap_or_default(), + exepath: exepath__.unwrap_or_default(), + exe_writable: exe_writable__.unwrap_or_default(), + exe_upper_layer: exe_upper_layer__.unwrap_or_default(), + exe_lower_layer: exe_lower_layer__.unwrap_or_default(), + exe_from_memfd: exe_from_memfd__.unwrap_or_default(), + args: args__.unwrap_or_default(), + env: env__.unwrap_or_default(), + cwd: cwd__.unwrap_or_default(), + fdlimit: fdlimit__.unwrap_or_default(), + flags: flags__.unwrap_or_default(), + uid: uid__.unwrap_or_default(), + gid: gid__.unwrap_or_default(), + cap_permitted: cap_permitted__.unwrap_or_default(), + cap_effective: cap_effective__.unwrap_or_default(), + cap_inheritable: cap_inheritable__.unwrap_or_default(), + exe_ino: exe_ino__.unwrap_or_default(), + exe_ino_ctime: exe_ino_ctime__.unwrap_or_default(), + exe_ino_mtime: exe_ino_mtime__.unwrap_or_default(), + exe_ino_ctime_duration_clone_ts: exe_ino_ctime_duration_clone_ts__.unwrap_or_default(), + exe_ino_ctime_duration_pidns_start: exe_ino_ctime_duration_pidns_start__.unwrap_or_default(), + vmsize_kb: vmsize_kb__.unwrap_or_default(), + vmrss_kb: vmrss_kb__.unwrap_or_default(), + vmswap_kb: vmswap_kb__.unwrap_or_default(), + pfmajor: pfmajor__.unwrap_or_default(), + pfminor: pfminor__.unwrap_or_default(), + vtid: vtid__, + vpid: vpid__, + pidns_init_start_ts: pidns_init_start_ts__.unwrap_or_default(), + cgroups: cgroups__.unwrap_or_default(), + root: root__.unwrap_or_default(), + filtered_out: filtered_out__.unwrap_or_default(), + fdlist: fdlist__.unwrap_or_default(), + clone_ts: clone_ts__.unwrap_or_default(), + tty: tty__.unwrap_or_default(), + loginuid: loginuid__.unwrap_or_default(), + lastexec_ts: lastexec_ts__.unwrap_or_default(), + reaper: reaper__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelThreadInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelThreadSnapshotEvent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if !self.thread_info.is_empty() { + len += 1; + } + if self.zone_boot_epoch != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelThreadSnapshotEvent", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.thread_info.is_empty() { + struct_ser.serialize_field("threadInfo", &self.thread_info)?; + } + if self.zone_boot_epoch != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("zoneBootEpoch", ToString::to_string(&self.zone_boot_epoch).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelThreadSnapshotEvent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "thread_info", + "threadInfo", + "zone_boot_epoch", + "zoneBootEpoch", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + ThreadInfo, + ZoneBootEpoch, + } + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "threadInfo" | "thread_info" => Ok(GeneratedField::ThreadInfo), + "zoneBootEpoch" | "zone_boot_epoch" => Ok(GeneratedField::ZoneBootEpoch), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelThreadSnapshotEvent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelThreadSnapshotEvent") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut thread_info__ = None; + let mut zone_boot_epoch__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); } - exe_ino_ctime__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + zone_id__ = Some(map_.next_value()?); } - GeneratedField::ExeInoMtime => { - if exe_ino_mtime__.is_some() { - return Err(serde::de::Error::duplicate_field("exeInoMtime")); + GeneratedField::ThreadInfo => { + if thread_info__.is_some() { + return Err(serde::de::Error::duplicate_field("threadInfo")); } - exe_ino_mtime__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + thread_info__ = Some( + map_.next_value::, _>>()? + .into_iter().map(|(k,v)| (k.0, v)).collect() + ); } - GeneratedField::ExeInoCtimeDurationCloneTs => { - if exe_ino_ctime_duration_clone_ts__.is_some() { - return Err(serde::de::Error::duplicate_field("exeInoCtimeDurationCloneTs")); + GeneratedField::ZoneBootEpoch => { + if zone_boot_epoch__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneBootEpoch")); } - exe_ino_ctime_duration_clone_ts__ = + zone_boot_epoch__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::ExeInoCtimeDurationPidnsStart => { - if exe_ino_ctime_duration_pidns_start__.is_some() { - return Err(serde::de::Error::duplicate_field("exeInoCtimeDurationPidnsStart")); - } - exe_ino_ctime_duration_pidns_start__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + } + } + Ok(ZoneKernelThreadSnapshotEvent { + zone_id: zone_id__.unwrap_or_default(), + thread_info: thread_info__.unwrap_or_default(), + zone_boot_epoch: zone_boot_epoch__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelThreadSnapshotEvent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelUdpFlow { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.local_address.is_empty() { + len += 1; + } + if self.local_port != 0 { + len += 1; + } + if !self.remote_address.is_empty() { + len += 1; + } + if self.remote_port != 0 { + len += 1; + } + if self.direction != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelUdpFlow", len)?; + if !self.local_address.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("localAddress", pbjson::private::base64::encode(&self.local_address).as_str())?; + } + if self.local_port != 0 { + struct_ser.serialize_field("localPort", &self.local_port)?; + } + if !self.remote_address.is_empty() { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("remoteAddress", pbjson::private::base64::encode(&self.remote_address).as_str())?; + } + if self.remote_port != 0 { + struct_ser.serialize_field("remotePort", &self.remote_port)?; + } + if self.direction != 0 { + let v = ZoneKernelNetworkDirection::try_from(self.direction) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?; + struct_ser.serialize_field("direction", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelUdpFlow { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "local_address", + "localAddress", + "local_port", + "localPort", + "remote_address", + "remoteAddress", + "remote_port", + "remotePort", + "direction", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + LocalAddress, + LocalPort, + RemoteAddress, + RemotePort, + Direction, + } + 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 { + "localAddress" | "local_address" => Ok(GeneratedField::LocalAddress), + "localPort" | "local_port" => Ok(GeneratedField::LocalPort), + "remoteAddress" | "remote_address" => Ok(GeneratedField::RemoteAddress), + "remotePort" | "remote_port" => Ok(GeneratedField::RemotePort), + "direction" => Ok(GeneratedField::Direction), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } - GeneratedField::VmsizeKb => { - if vmsize_kb__.is_some() { - return Err(serde::de::Error::duplicate_field("vmsizeKb")); + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelUdpFlow; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelUdpFlow") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut local_address__ = None; + let mut local_port__ = None; + let mut remote_address__ = None; + let mut remote_port__ = None; + let mut direction__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::LocalAddress => { + if local_address__.is_some() { + return Err(serde::de::Error::duplicate_field("localAddress")); } - vmsize_kb__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + local_address__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } - GeneratedField::VmrssKb => { - if vmrss_kb__.is_some() { - return Err(serde::de::Error::duplicate_field("vmrssKb")); + GeneratedField::LocalPort => { + if local_port__.is_some() { + return Err(serde::de::Error::duplicate_field("localPort")); } - vmrss_kb__ = + local_port__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::VmswapKb => { - if vmswap_kb__.is_some() { - return Err(serde::de::Error::duplicate_field("vmswapKb")); - } - vmswap_kb__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + GeneratedField::RemoteAddress => { + if remote_address__.is_some() { + return Err(serde::de::Error::duplicate_field("remoteAddress")); + } + remote_address__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } - GeneratedField::Pfmajor => { - if pfmajor__.is_some() { - return Err(serde::de::Error::duplicate_field("pfmajor")); + GeneratedField::RemotePort => { + if remote_port__.is_some() { + return Err(serde::de::Error::duplicate_field("remotePort")); } - pfmajor__ = + remote_port__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Pfminor => { - if pfminor__.is_some() { - return Err(serde::de::Error::duplicate_field("pfminor")); + GeneratedField::Direction => { + if direction__.is_some() { + return Err(serde::de::Error::duplicate_field("direction")); } - pfminor__ = + direction__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(ZoneKernelUdpFlow { + local_address: local_address__.unwrap_or_default(), + local_port: local_port__.unwrap_or_default(), + remote_address: remote_address__.unwrap_or_default(), + remote_port: remote_port__.unwrap_or_default(), + direction: direction__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelUdpFlow", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneKernelUnixSocketInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.source != 0 { + len += 1; + } + if self.destination != 0 { + len += 1; + } + if !self.name.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelUnixSocketInfo", len)?; + if self.source != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("source", ToString::to_string(&self.source).as_str())?; + } + if self.destination != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("destination", ToString::to_string(&self.destination).as_str())?; + } + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneKernelUnixSocketInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "source", + "destination", + "name", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Source, + Destination, + Name, + } + 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 { + "source" => Ok(GeneratedField::Source), + "destination" => Ok(GeneratedField::Destination), + "name" => Ok(GeneratedField::Name), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneKernelUnixSocketInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneKernelUnixSocketInfo") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut source__ = None; + let mut destination__ = None; + let mut name__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Source => { + if source__.is_some() { + return Err(serde::de::Error::duplicate_field("source")); + } + source__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Vtid => { - if vtid__.is_some() { - return Err(serde::de::Error::duplicate_field("vtid")); + GeneratedField::Destination => { + if destination__.is_some() { + return Err(serde::de::Error::duplicate_field("destination")); } - vtid__ = - map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + destination__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Vpid => { - if vpid__.is_some() { - return Err(serde::de::Error::duplicate_field("vpid")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - vpid__ = - map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) - ; + name__ = Some(map_.next_value()?); } - GeneratedField::PidnsInitStartTs => { - if pidns_init_start_ts__.is_some() { - return Err(serde::de::Error::duplicate_field("pidnsInitStartTs")); + } + } + Ok(ZoneKernelUnixSocketInfo { + source: source__.unwrap_or_default(), + destination: destination__.unwrap_or_default(), + name: name__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneKernelUnixSocketInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneMountStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.device_id != 0 { + len += 1; + } + if !self.host_path.is_empty() { + len += 1; + } + if !self.tag.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneMountStatus", len)?; + if self.device_id != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("deviceId", ToString::to_string(&self.device_id).as_str())?; + } + if !self.host_path.is_empty() { + struct_ser.serialize_field("hostPath", &self.host_path)?; + } + if !self.tag.is_empty() { + struct_ser.serialize_field("tag", &self.tag)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneMountStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "device_id", + "deviceId", + "host_path", + "hostPath", + "tag", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + DeviceId, + HostPath, + Tag, + } + 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 { + "deviceId" | "device_id" => Ok(GeneratedField::DeviceId), + "hostPath" | "host_path" => Ok(GeneratedField::HostPath), + "tag" => Ok(GeneratedField::Tag), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneMountStatus; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneMountStatus") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut device_id__ = None; + let mut host_path__ = None; + let mut tag__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::DeviceId => { + if device_id__.is_some() { + return Err(serde::de::Error::duplicate_field("deviceId")); } - pidns_init_start_ts__ = + device_id__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Cgroups => { - if cgroups__.is_some() { - return Err(serde::de::Error::duplicate_field("cgroups")); + GeneratedField::HostPath => { + if host_path__.is_some() { + return Err(serde::de::Error::duplicate_field("hostPath")); } - cgroups__ = Some(map_.next_value()?); + host_path__ = Some(map_.next_value()?); } - GeneratedField::Root => { - if root__.is_some() { - return Err(serde::de::Error::duplicate_field("root")); + GeneratedField::Tag => { + if tag__.is_some() { + return Err(serde::de::Error::duplicate_field("tag")); } - root__ = Some(map_.next_value()?); + tag__ = Some(map_.next_value()?); } - GeneratedField::FilteredOut => { - if filtered_out__.is_some() { - return Err(serde::de::Error::duplicate_field("filteredOut")); + } + } + Ok(ZoneMountStatus { + device_id: device_id__.unwrap_or_default(), + host_path: host_path__.unwrap_or_default(), + tag: tag__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneMountStatus", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneNetworkBackend { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Default => "ZONE_NETWORK_BACKEND_DEFAULT", + Self::None => "ZONE_NETWORK_BACKEND_NONE", + Self::External => "ZONE_NETWORK_BACKEND_EXTERNAL", + Self::Passthrough => "ZONE_NETWORK_BACKEND_PASSTHROUGH", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneNetworkBackend { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_NETWORK_BACKEND_DEFAULT", + "ZONE_NETWORK_BACKEND_NONE", + "ZONE_NETWORK_BACKEND_EXTERNAL", + "ZONE_NETWORK_BACKEND_PASSTHROUGH", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneNetworkBackend; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_NETWORK_BACKEND_DEFAULT" => Ok(ZoneNetworkBackend::Default), + "ZONE_NETWORK_BACKEND_NONE" => Ok(ZoneNetworkBackend::None), + "ZONE_NETWORK_BACKEND_EXTERNAL" => Ok(ZoneNetworkBackend::External), + "ZONE_NETWORK_BACKEND_PASSTHROUGH" => Ok(ZoneNetworkBackend::Passthrough), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ZoneNetworkConfig { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.interfaces.is_empty() { + len += 1; + } + if !self.routes.is_empty() { + len += 1; + } + if !self.neighbors.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkConfig", len)?; + if !self.interfaces.is_empty() { + struct_ser.serialize_field("interfaces", &self.interfaces)?; + } + if !self.routes.is_empty() { + struct_ser.serialize_field("routes", &self.routes)?; + } + if !self.neighbors.is_empty() { + struct_ser.serialize_field("neighbors", &self.neighbors)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneNetworkConfig { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "interfaces", + "routes", + "neighbors", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Interfaces, + Routes, + Neighbors, + } + 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 { + "interfaces" => Ok(GeneratedField::Interfaces), + "routes" => Ok(GeneratedField::Routes), + "neighbors" => Ok(GeneratedField::Neighbors), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneNetworkConfig; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneNetworkConfig") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut interfaces__ = None; + let mut routes__ = None; + let mut neighbors__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Interfaces => { + if interfaces__.is_some() { + return Err(serde::de::Error::duplicate_field("interfaces")); } - filtered_out__ = Some(map_.next_value()?); + interfaces__ = Some(map_.next_value()?); } - GeneratedField::Fdlist => { - if fdlist__.is_some() { - return Err(serde::de::Error::duplicate_field("fdlist")); + GeneratedField::Routes => { + if routes__.is_some() { + return Err(serde::de::Error::duplicate_field("routes")); } - fdlist__ = Some( - map_.next_value::, _>>()? - .into_iter().map(|(k,v)| (k.0, v)).collect() - ); + routes__ = Some(map_.next_value()?); + } + GeneratedField::Neighbors => { + if neighbors__.is_some() { + return Err(serde::de::Error::duplicate_field("neighbors")); + } + neighbors__ = Some(map_.next_value()?); + } + } + } + Ok(ZoneNetworkConfig { + interfaces: interfaces__.unwrap_or_default(), + routes: routes__.unwrap_or_default(), + neighbors: neighbors__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneNetworkConfig", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneNetworkInterfaceConfig { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_interface.is_empty() { + len += 1; + } + if !self.zone_mac.is_empty() { + len += 1; + } + if !self.ips.is_empty() { + len += 1; + } + if self.mtu != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkInterfaceConfig", len)?; + if !self.zone_interface.is_empty() { + struct_ser.serialize_field("zoneInterface", &self.zone_interface)?; + } + if !self.zone_mac.is_empty() { + struct_ser.serialize_field("zoneMac", &self.zone_mac)?; + } + if !self.ips.is_empty() { + struct_ser.serialize_field("ips", &self.ips)?; + } + if self.mtu != 0 { + struct_ser.serialize_field("mtu", &self.mtu)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneNetworkInterfaceConfig { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_interface", + "zoneInterface", + "zone_mac", + "zoneMac", + "ips", + "mtu", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneInterface, + ZoneMac, + Ips, + Mtu, + } + 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 { + "zoneInterface" | "zone_interface" => Ok(GeneratedField::ZoneInterface), + "zoneMac" | "zone_mac" => Ok(GeneratedField::ZoneMac), + "ips" => Ok(GeneratedField::Ips), + "mtu" => Ok(GeneratedField::Mtu), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } - GeneratedField::CloneTs => { - if clone_ts__.is_some() { - return Err(serde::de::Error::duplicate_field("cloneTs")); + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneNetworkInterfaceConfig; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneNetworkInterfaceConfig") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_interface__ = None; + let mut zone_mac__ = None; + let mut ips__ = None; + let mut mtu__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneInterface => { + if zone_interface__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneInterface")); } - clone_ts__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + zone_interface__ = Some(map_.next_value()?); } - GeneratedField::Tty => { - if tty__.is_some() { - return Err(serde::de::Error::duplicate_field("tty")); + GeneratedField::ZoneMac => { + if zone_mac__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneMac")); } - tty__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + zone_mac__ = Some(map_.next_value()?); } - GeneratedField::Loginuid => { - if loginuid__.is_some() { - return Err(serde::de::Error::duplicate_field("loginuid")); + GeneratedField::Ips => { + if ips__.is_some() { + return Err(serde::de::Error::duplicate_field("ips")); } - loginuid__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + ips__ = Some(map_.next_value()?); } - GeneratedField::LastexecTs => { - if lastexec_ts__.is_some() { - return Err(serde::de::Error::duplicate_field("lastexecTs")); + GeneratedField::Mtu => { + if mtu__.is_some() { + return Err(serde::de::Error::duplicate_field("mtu")); } - lastexec_ts__ = + mtu__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Reaper => { - if reaper__.is_some() { - return Err(serde::de::Error::duplicate_field("reaper")); - } - reaper__ = Some(map_.next_value()?); - } } } - Ok(ZoneKernelThreadInfo { - tid: tid__, - pid: pid__, - ptid: ptid__, - sid: sid__.unwrap_or_default(), - vpgid: vpgid__.unwrap_or_default(), - pgid: pgid__.unwrap_or_default(), - comm: comm__.unwrap_or_default(), - exe: exe__.unwrap_or_default(), - exepath: exepath__.unwrap_or_default(), - exe_writable: exe_writable__.unwrap_or_default(), - exe_upper_layer: exe_upper_layer__.unwrap_or_default(), - exe_lower_layer: exe_lower_layer__.unwrap_or_default(), - exe_from_memfd: exe_from_memfd__.unwrap_or_default(), - args: args__.unwrap_or_default(), - env: env__.unwrap_or_default(), - cwd: cwd__.unwrap_or_default(), - fdlimit: fdlimit__.unwrap_or_default(), - flags: flags__.unwrap_or_default(), - uid: uid__.unwrap_or_default(), - gid: gid__.unwrap_or_default(), - cap_permitted: cap_permitted__.unwrap_or_default(), - cap_effective: cap_effective__.unwrap_or_default(), - cap_inheritable: cap_inheritable__.unwrap_or_default(), - exe_ino: exe_ino__.unwrap_or_default(), - exe_ino_ctime: exe_ino_ctime__.unwrap_or_default(), - exe_ino_mtime: exe_ino_mtime__.unwrap_or_default(), - exe_ino_ctime_duration_clone_ts: exe_ino_ctime_duration_clone_ts__.unwrap_or_default(), - exe_ino_ctime_duration_pidns_start: exe_ino_ctime_duration_pidns_start__.unwrap_or_default(), - vmsize_kb: vmsize_kb__.unwrap_or_default(), - vmrss_kb: vmrss_kb__.unwrap_or_default(), - vmswap_kb: vmswap_kb__.unwrap_or_default(), - pfmajor: pfmajor__.unwrap_or_default(), - pfminor: pfminor__.unwrap_or_default(), - vtid: vtid__, - vpid: vpid__, - pidns_init_start_ts: pidns_init_start_ts__.unwrap_or_default(), - cgroups: cgroups__.unwrap_or_default(), - root: root__.unwrap_or_default(), - filtered_out: filtered_out__.unwrap_or_default(), - fdlist: fdlist__.unwrap_or_default(), - clone_ts: clone_ts__.unwrap_or_default(), - tty: tty__.unwrap_or_default(), - loginuid: loginuid__.unwrap_or_default(), - lastexec_ts: lastexec_ts__.unwrap_or_default(), - reaper: reaper__.unwrap_or_default(), + Ok(ZoneNetworkInterfaceConfig { + zone_interface: zone_interface__.unwrap_or_default(), + zone_mac: zone_mac__.unwrap_or_default(), + ips: ips__.unwrap_or_default(), + mtu: mtu__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelThreadInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneNetworkInterfaceConfig", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelThreadSnapshotEvent { +impl serde::Serialize for ZoneNetworkInterfaceStatus { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -18165,50 +30442,64 @@ impl serde::Serialize for ZoneKernelThreadSnapshotEvent { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_id.is_empty() { + if !self.host_interface.is_empty() { len += 1; } - if !self.thread_info.is_empty() { + if !self.zone_interface.is_empty() { len += 1; } - if self.zone_boot_epoch != 0 { + if !self.zone_mac.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelThreadSnapshotEvent", len)?; - if !self.zone_id.is_empty() { - struct_ser.serialize_field("zoneId", &self.zone_id)?; + if !self.ips.is_empty() { + len += 1; } - if !self.thread_info.is_empty() { - struct_ser.serialize_field("threadInfo", &self.thread_info)?; + if self.mtu != 0 { + len += 1; } - if self.zone_boot_epoch != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("zoneBootEpoch", ToString::to_string(&self.zone_boot_epoch).as_str())?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkInterfaceStatus", len)?; + if !self.host_interface.is_empty() { + struct_ser.serialize_field("hostInterface", &self.host_interface)?; + } + if !self.zone_interface.is_empty() { + struct_ser.serialize_field("zoneInterface", &self.zone_interface)?; + } + if !self.zone_mac.is_empty() { + struct_ser.serialize_field("zoneMac", &self.zone_mac)?; + } + if !self.ips.is_empty() { + struct_ser.serialize_field("ips", &self.ips)?; + } + if self.mtu != 0 { + struct_ser.serialize_field("mtu", &self.mtu)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelThreadSnapshotEvent { +impl<'de> serde::Deserialize<'de> for ZoneNetworkInterfaceStatus { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_id", - "zoneId", - "thread_info", - "threadInfo", - "zone_boot_epoch", - "zoneBootEpoch", + "host_interface", + "hostInterface", + "zone_interface", + "zoneInterface", + "zone_mac", + "zoneMac", + "ips", + "mtu", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneId, - ThreadInfo, - ZoneBootEpoch, + HostInterface, + ZoneInterface, + ZoneMac, + Ips, + Mtu, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -18228,11 +30519,13 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelThreadSnapshotEvent { fn visit_str(self, value: &str) -> std::result::Result where E: serde::de::Error, - { - match value { - "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), - "threadInfo" | "thread_info" => Ok(GeneratedField::ThreadInfo), - "zoneBootEpoch" | "zone_boot_epoch" => Ok(GeneratedField::ZoneBootEpoch), + { + match value { + "hostInterface" | "host_interface" => Ok(GeneratedField::HostInterface), + "zoneInterface" | "zone_interface" => Ok(GeneratedField::ZoneInterface), + "zoneMac" | "zone_mac" => Ok(GeneratedField::ZoneMac), + "ips" => Ok(GeneratedField::Ips), + "mtu" => Ok(GeneratedField::Mtu), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -18242,57 +30535,70 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelThreadSnapshotEvent { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelThreadSnapshotEvent; + type Value = ZoneNetworkInterfaceStatus; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelThreadSnapshotEvent") + formatter.write_str("struct protect.control.v1.ZoneNetworkInterfaceStatus") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_id__ = None; - let mut thread_info__ = None; - let mut zone_boot_epoch__ = None; + let mut host_interface__ = None; + let mut zone_interface__ = None; + let mut zone_mac__ = None; + let mut ips__ = None; + let mut mtu__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneId => { - if zone_id__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneId")); + GeneratedField::HostInterface => { + if host_interface__.is_some() { + return Err(serde::de::Error::duplicate_field("hostInterface")); } - zone_id__ = Some(map_.next_value()?); + host_interface__ = Some(map_.next_value()?); } - GeneratedField::ThreadInfo => { - if thread_info__.is_some() { - return Err(serde::de::Error::duplicate_field("threadInfo")); + GeneratedField::ZoneInterface => { + if zone_interface__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneInterface")); } - thread_info__ = Some( - map_.next_value::, _>>()? - .into_iter().map(|(k,v)| (k.0, v)).collect() - ); + zone_interface__ = Some(map_.next_value()?); } - GeneratedField::ZoneBootEpoch => { - if zone_boot_epoch__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneBootEpoch")); + GeneratedField::ZoneMac => { + if zone_mac__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneMac")); } - zone_boot_epoch__ = + zone_mac__ = Some(map_.next_value()?); + } + GeneratedField::Ips => { + if ips__.is_some() { + return Err(serde::de::Error::duplicate_field("ips")); + } + ips__ = Some(map_.next_value()?); + } + GeneratedField::Mtu => { + if mtu__.is_some() { + return Err(serde::de::Error::duplicate_field("mtu")); + } + mtu__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } } } - Ok(ZoneKernelThreadSnapshotEvent { - zone_id: zone_id__.unwrap_or_default(), - thread_info: thread_info__.unwrap_or_default(), - zone_boot_epoch: zone_boot_epoch__.unwrap_or_default(), + Ok(ZoneNetworkInterfaceStatus { + host_interface: host_interface__.unwrap_or_default(), + zone_interface: zone_interface__.unwrap_or_default(), + zone_mac: zone_mac__.unwrap_or_default(), + ips: ips__.unwrap_or_default(), + mtu: mtu__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelThreadSnapshotEvent", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneNetworkInterfaceStatus", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneKernelUnixSocketInfo { +impl serde::Serialize for ZoneNetworkIp { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -18300,49 +30606,47 @@ impl serde::Serialize for ZoneKernelUnixSocketInfo { { use serde::ser::SerializeStruct; let mut len = 0; - if self.source != 0 { + if self.version != 0 { len += 1; } - if self.destination != 0 { + if !self.address.is_empty() { len += 1; } - if !self.name.is_empty() { + if !self.gateway.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneKernelUnixSocketInfo", len)?; - if self.source != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("source", ToString::to_string(&self.source).as_str())?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkIp", len)?; + if self.version != 0 { + let v = ZoneNetworkIpVersion::try_from(self.version) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?; + struct_ser.serialize_field("version", &v)?; } - if self.destination != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("destination", ToString::to_string(&self.destination).as_str())?; + if !self.address.is_empty() { + struct_ser.serialize_field("address", &self.address)?; } - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; + if !self.gateway.is_empty() { + struct_ser.serialize_field("gateway", &self.gateway)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneKernelUnixSocketInfo { +impl<'de> serde::Deserialize<'de> for ZoneNetworkIp { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "source", - "destination", - "name", + "version", + "address", + "gateway", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Source, - Destination, - Name, + Version, + Address, + Gateway, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -18364,9 +30668,9 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelUnixSocketInfo { E: serde::de::Error, { match value { - "source" => Ok(GeneratedField::Source), - "destination" => Ok(GeneratedField::Destination), - "name" => Ok(GeneratedField::Name), + "version" => Ok(GeneratedField::Version), + "address" => Ok(GeneratedField::Address), + "gateway" => Ok(GeneratedField::Gateway), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -18376,218 +30680,155 @@ impl<'de> serde::Deserialize<'de> for ZoneKernelUnixSocketInfo { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneKernelUnixSocketInfo; + type Value = ZoneNetworkIp; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneKernelUnixSocketInfo") + formatter.write_str("struct protect.control.v1.ZoneNetworkIp") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut source__ = None; - let mut destination__ = None; - let mut name__ = None; + let mut version__ = None; + let mut address__ = None; + let mut gateway__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Source => { - if source__.is_some() { - return Err(serde::de::Error::duplicate_field("source")); + GeneratedField::Version => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("version")); } - source__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + version__ = Some(map_.next_value::()? as i32); } - GeneratedField::Destination => { - if destination__.is_some() { - return Err(serde::de::Error::duplicate_field("destination")); + GeneratedField::Address => { + if address__.is_some() { + return Err(serde::de::Error::duplicate_field("address")); } - destination__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + address__ = Some(map_.next_value()?); } - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); + GeneratedField::Gateway => { + if gateway__.is_some() { + return Err(serde::de::Error::duplicate_field("gateway")); } - name__ = Some(map_.next_value()?); + gateway__ = Some(map_.next_value()?); } } } - Ok(ZoneKernelUnixSocketInfo { - source: source__.unwrap_or_default(), - destination: destination__.unwrap_or_default(), - name: name__.unwrap_or_default(), + Ok(ZoneNetworkIp { + version: version__.unwrap_or_default(), + address: address__.unwrap_or_default(), + gateway: gateway__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneKernelUnixSocketInfo", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneNetworkIp", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneMountStatus { +impl serde::Serialize for ZoneNetworkIpVersion { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.device_id != 0 { - len += 1; - } - if !self.host_path.is_empty() { - len += 1; - } - if !self.tag.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneMountStatus", len)?; - if self.device_id != 0 { - #[allow(clippy::needless_borrow)] - #[allow(clippy::needless_borrows_for_generic_args)] - struct_ser.serialize_field("deviceId", ToString::to_string(&self.device_id).as_str())?; - } - if !self.host_path.is_empty() { - struct_ser.serialize_field("hostPath", &self.host_path)?; - } - if !self.tag.is_empty() { - struct_ser.serialize_field("tag", &self.tag)?; - } - struct_ser.end() + let variant = match self { + Self::Unknown => "ZONE_NETWORK_IP_VERSION_UNKNOWN", + Self::V4 => "ZONE_NETWORK_IP_VERSION_V4", + Self::V6 => "ZONE_NETWORK_IP_VERSION_V6", + }; + serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for ZoneMountStatus { +impl<'de> serde::Deserialize<'de> for ZoneNetworkIpVersion { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "device_id", - "deviceId", - "host_path", - "hostPath", - "tag", + "ZONE_NETWORK_IP_VERSION_UNKNOWN", + "ZONE_NETWORK_IP_VERSION_V4", + "ZONE_NETWORK_IP_VERSION_V6", ]; - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - DeviceId, - HostPath, - Tag, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; + struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneNetworkIpVersion; - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } + 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 { - "deviceId" | "device_id" => Ok(GeneratedField::DeviceId), - "hostPath" | "host_path" => Ok(GeneratedField::HostPath), - "tag" => Ok(GeneratedField::Tag), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneMountStatus; - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneMountStatus") + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) } - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, { - let mut device_id__ = None; - let mut host_path__ = None; - let mut tag__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::DeviceId => { - if device_id__.is_some() { - return Err(serde::de::Error::duplicate_field("deviceId")); - } - device_id__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::HostPath => { - if host_path__.is_some() { - return Err(serde::de::Error::duplicate_field("hostPath")); - } - host_path__ = Some(map_.next_value()?); - } - GeneratedField::Tag => { - if tag__.is_some() { - return Err(serde::de::Error::duplicate_field("tag")); - } - tag__ = Some(map_.next_value()?); - } - } + match value { + "ZONE_NETWORK_IP_VERSION_UNKNOWN" => Ok(ZoneNetworkIpVersion::Unknown), + "ZONE_NETWORK_IP_VERSION_V4" => Ok(ZoneNetworkIpVersion::V4), + "ZONE_NETWORK_IP_VERSION_V6" => Ok(ZoneNetworkIpVersion::V6), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } - Ok(ZoneMountStatus { - device_id: device_id__.unwrap_or_default(), - host_path: host_path__.unwrap_or_default(), - tag: tag__.unwrap_or_default(), - }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneMountStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkBackend { +impl serde::Serialize for ZoneNetworkNudMode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { let variant = match self { - Self::Default => "ZONE_NETWORK_BACKEND_DEFAULT", - Self::None => "ZONE_NETWORK_BACKEND_NONE", - Self::External => "ZONE_NETWORK_BACKEND_EXTERNAL", - Self::Passthrough => "ZONE_NETWORK_BACKEND_PASSTHROUGH", + Self::Permanent => "ZONE_NETWORK_NUD_MODE_PERMANENT", + Self::Noarp => "ZONE_NETWORK_NUD_MODE_NOARP", + Self::Reachable => "ZONE_NETWORK_NUD_MODE_REACHABLE", }; serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkBackend { +impl<'de> serde::Deserialize<'de> for ZoneNetworkNudMode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ZONE_NETWORK_BACKEND_DEFAULT", - "ZONE_NETWORK_BACKEND_NONE", - "ZONE_NETWORK_BACKEND_EXTERNAL", - "ZONE_NETWORK_BACKEND_PASSTHROUGH", + "ZONE_NETWORK_NUD_MODE_PERMANENT", + "ZONE_NETWORK_NUD_MODE_NOARP", + "ZONE_NETWORK_NUD_MODE_REACHABLE", ]; struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkBackend; + type Value = ZoneNetworkNudMode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(formatter, "expected one of: {:?}", &FIELDS) @@ -18622,10 +30863,9 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkBackend { E: serde::de::Error, { match value { - "ZONE_NETWORK_BACKEND_DEFAULT" => Ok(ZoneNetworkBackend::Default), - "ZONE_NETWORK_BACKEND_NONE" => Ok(ZoneNetworkBackend::None), - "ZONE_NETWORK_BACKEND_EXTERNAL" => Ok(ZoneNetworkBackend::External), - "ZONE_NETWORK_BACKEND_PASSTHROUGH" => Ok(ZoneNetworkBackend::Passthrough), + "ZONE_NETWORK_NUD_MODE_PERMANENT" => Ok(ZoneNetworkNudMode::Permanent), + "ZONE_NETWORK_NUD_MODE_NOARP" => Ok(ZoneNetworkNudMode::Noarp), + "ZONE_NETWORK_NUD_MODE_REACHABLE" => Ok(ZoneNetworkNudMode::Reachable), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -18633,7 +30873,7 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkBackend { deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkConfig { +impl serde::Serialize for ZoneNetworkNeighborEntry { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -18641,45 +30881,77 @@ impl serde::Serialize for ZoneNetworkConfig { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.interfaces.is_empty() { + if self.version != 0 { len += 1; } - if !self.routes.is_empty() { + if !self.ip_address.is_empty() { len += 1; } - if !self.neighbors.is_empty() { + if !self.link_layer_address.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkConfig", len)?; - if !self.interfaces.is_empty() { - struct_ser.serialize_field("interfaces", &self.interfaces)?; + if !self.attached_interface.is_empty() { + len += 1; } - if !self.routes.is_empty() { - struct_ser.serialize_field("routes", &self.routes)?; + if self.unreachability_detection != 0 { + len += 1; } - if !self.neighbors.is_empty() { - struct_ser.serialize_field("neighbors", &self.neighbors)?; + if self.kind != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkNeighborEntry", len)?; + if self.version != 0 { + let v = ZoneNetworkIpVersion::try_from(self.version) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?; + struct_ser.serialize_field("version", &v)?; + } + if !self.ip_address.is_empty() { + struct_ser.serialize_field("ipAddress", &self.ip_address)?; + } + if !self.link_layer_address.is_empty() { + struct_ser.serialize_field("linkLayerAddress", &self.link_layer_address)?; + } + if !self.attached_interface.is_empty() { + struct_ser.serialize_field("attachedInterface", &self.attached_interface)?; + } + if self.unreachability_detection != 0 { + let v = ZoneNetworkNudMode::try_from(self.unreachability_detection) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.unreachability_detection)))?; + struct_ser.serialize_field("unreachabilityDetection", &v)?; + } + if self.kind != 0 { + struct_ser.serialize_field("kind", &self.kind)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkConfig { +impl<'de> serde::Deserialize<'de> for ZoneNetworkNeighborEntry { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "interfaces", - "routes", - "neighbors", + "version", + "ip_address", + "ipAddress", + "link_layer_address", + "linkLayerAddress", + "attached_interface", + "attachedInterface", + "unreachability_detection", + "unreachabilityDetection", + "kind", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Interfaces, - Routes, - Neighbors, + Version, + IpAddress, + LinkLayerAddress, + AttachedInterface, + UnreachabilityDetection, + Kind, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -18701,9 +30973,12 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkConfig { E: serde::de::Error, { match value { - "interfaces" => Ok(GeneratedField::Interfaces), - "routes" => Ok(GeneratedField::Routes), - "neighbors" => Ok(GeneratedField::Neighbors), + "version" => Ok(GeneratedField::Version), + "ipAddress" | "ip_address" => Ok(GeneratedField::IpAddress), + "linkLayerAddress" | "link_layer_address" => Ok(GeneratedField::LinkLayerAddress), + "attachedInterface" | "attached_interface" => Ok(GeneratedField::AttachedInterface), + "unreachabilityDetection" | "unreachability_detection" => Ok(GeneratedField::UnreachabilityDetection), + "kind" => Ok(GeneratedField::Kind), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -18713,52 +30988,78 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkConfig { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkConfig; + type Value = ZoneNetworkNeighborEntry; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneNetworkConfig") + formatter.write_str("struct protect.control.v1.ZoneNetworkNeighborEntry") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut interfaces__ = None; - let mut routes__ = None; - let mut neighbors__ = None; + let mut version__ = None; + let mut ip_address__ = None; + let mut link_layer_address__ = None; + let mut attached_interface__ = None; + let mut unreachability_detection__ = None; + let mut kind__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Interfaces => { - if interfaces__.is_some() { - return Err(serde::de::Error::duplicate_field("interfaces")); + GeneratedField::Version => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("version")); } - interfaces__ = Some(map_.next_value()?); + version__ = Some(map_.next_value::()? as i32); } - GeneratedField::Routes => { - if routes__.is_some() { - return Err(serde::de::Error::duplicate_field("routes")); + GeneratedField::IpAddress => { + if ip_address__.is_some() { + return Err(serde::de::Error::duplicate_field("ipAddress")); } - routes__ = Some(map_.next_value()?); + ip_address__ = Some(map_.next_value()?); } - GeneratedField::Neighbors => { - if neighbors__.is_some() { - return Err(serde::de::Error::duplicate_field("neighbors")); + GeneratedField::LinkLayerAddress => { + if link_layer_address__.is_some() { + return Err(serde::de::Error::duplicate_field("linkLayerAddress")); } - neighbors__ = Some(map_.next_value()?); + link_layer_address__ = Some(map_.next_value()?); + } + GeneratedField::AttachedInterface => { + if attached_interface__.is_some() { + return Err(serde::de::Error::duplicate_field("attachedInterface")); + } + attached_interface__ = Some(map_.next_value()?); + } + GeneratedField::UnreachabilityDetection => { + if unreachability_detection__.is_some() { + return Err(serde::de::Error::duplicate_field("unreachabilityDetection")); + } + unreachability_detection__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Kind => { + if kind__.is_some() { + return Err(serde::de::Error::duplicate_field("kind")); + } + kind__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(ZoneNetworkConfig { - interfaces: interfaces__.unwrap_or_default(), - routes: routes__.unwrap_or_default(), - neighbors: neighbors__.unwrap_or_default(), + Ok(ZoneNetworkNeighborEntry { + version: version__.unwrap_or_default(), + ip_address: ip_address__.unwrap_or_default(), + link_layer_address: link_layer_address__.unwrap_or_default(), + attached_interface: attached_interface__.unwrap_or_default(), + unreachability_detection: unreachability_detection__.unwrap_or_default(), + kind: kind__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneNetworkConfig", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneNetworkNeighborEntry", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkInterfaceConfig { +impl serde::Serialize for ZoneNetworkOptionsDnsSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -18766,55 +31067,45 @@ impl serde::Serialize for ZoneNetworkInterfaceConfig { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.zone_interface.is_empty() { - len += 1; - } - if !self.zone_mac.is_empty() { + if !self.nameservers.is_empty() { len += 1; } - if !self.ips.is_empty() { + if !self.searches.is_empty() { len += 1; } - if self.mtu != 0 { + if !self.options.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkInterfaceConfig", len)?; - if !self.zone_interface.is_empty() { - struct_ser.serialize_field("zoneInterface", &self.zone_interface)?; - } - if !self.zone_mac.is_empty() { - struct_ser.serialize_field("zoneMac", &self.zone_mac)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkOptionsDnsSpec", len)?; + if !self.nameservers.is_empty() { + struct_ser.serialize_field("nameservers", &self.nameservers)?; } - if !self.ips.is_empty() { - struct_ser.serialize_field("ips", &self.ips)?; + if !self.searches.is_empty() { + struct_ser.serialize_field("searches", &self.searches)?; } - if self.mtu != 0 { - struct_ser.serialize_field("mtu", &self.mtu)?; + if !self.options.is_empty() { + struct_ser.serialize_field("options", &self.options)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkInterfaceConfig { +impl<'de> serde::Deserialize<'de> for ZoneNetworkOptionsDnsSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "zone_interface", - "zoneInterface", - "zone_mac", - "zoneMac", - "ips", - "mtu", + "nameservers", + "searches", + "options", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ZoneInterface, - ZoneMac, - Ips, - Mtu, + Nameservers, + Searches, + Options, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -18836,10 +31127,9 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkInterfaceConfig { E: serde::de::Error, { match value { - "zoneInterface" | "zone_interface" => Ok(GeneratedField::ZoneInterface), - "zoneMac" | "zone_mac" => Ok(GeneratedField::ZoneMac), - "ips" => Ok(GeneratedField::Ips), - "mtu" => Ok(GeneratedField::Mtu), + "nameservers" => Ok(GeneratedField::Nameservers), + "searches" => Ok(GeneratedField::Searches), + "options" => Ok(GeneratedField::Options), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -18849,62 +31139,52 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkInterfaceConfig { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkInterfaceConfig; + type Value = ZoneNetworkOptionsDnsSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneNetworkInterfaceConfig") + formatter.write_str("struct protect.control.v1.ZoneNetworkOptionsDnsSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut zone_interface__ = None; - let mut zone_mac__ = None; - let mut ips__ = None; - let mut mtu__ = None; + let mut nameservers__ = None; + let mut searches__ = None; + let mut options__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::ZoneInterface => { - if zone_interface__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneInterface")); - } - zone_interface__ = Some(map_.next_value()?); - } - GeneratedField::ZoneMac => { - if zone_mac__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneMac")); + GeneratedField::Nameservers => { + if nameservers__.is_some() { + return Err(serde::de::Error::duplicate_field("nameservers")); } - zone_mac__ = Some(map_.next_value()?); + nameservers__ = Some(map_.next_value()?); } - GeneratedField::Ips => { - if ips__.is_some() { - return Err(serde::de::Error::duplicate_field("ips")); + GeneratedField::Searches => { + if searches__.is_some() { + return Err(serde::de::Error::duplicate_field("searches")); } - ips__ = Some(map_.next_value()?); + searches__ = Some(map_.next_value()?); } - GeneratedField::Mtu => { - if mtu__.is_some() { - return Err(serde::de::Error::duplicate_field("mtu")); + GeneratedField::Options => { + if options__.is_some() { + return Err(serde::de::Error::duplicate_field("options")); } - mtu__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + options__ = Some(map_.next_value()?); } } } - Ok(ZoneNetworkInterfaceConfig { - zone_interface: zone_interface__.unwrap_or_default(), - zone_mac: zone_mac__.unwrap_or_default(), - ips: ips__.unwrap_or_default(), - mtu: mtu__.unwrap_or_default(), + Ok(ZoneNetworkOptionsDnsSpec { + nameservers: nameservers__.unwrap_or_default(), + searches: searches__.unwrap_or_default(), + options: options__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneNetworkInterfaceConfig", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneNetworkOptionsDnsSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkInterfaceStatus { +impl serde::Serialize for ZoneNetworkOptionsSpec { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -18912,64 +31192,58 @@ impl serde::Serialize for ZoneNetworkInterfaceStatus { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.host_interface.is_empty() { - len += 1; - } - if !self.zone_interface.is_empty() { + if !self.assume_network_reservation.is_empty() { len += 1; } - if !self.zone_mac.is_empty() { + if self.retain_network_reservation { len += 1; } - if !self.ips.is_empty() { + if self.dns_config.is_some() { len += 1; } - if self.mtu != 0 { + if self.backend != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkInterfaceStatus", len)?; - if !self.host_interface.is_empty() { - struct_ser.serialize_field("hostInterface", &self.host_interface)?; - } - if !self.zone_interface.is_empty() { - struct_ser.serialize_field("zoneInterface", &self.zone_interface)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkOptionsSpec", len)?; + if !self.assume_network_reservation.is_empty() { + struct_ser.serialize_field("assumeNetworkReservation", &self.assume_network_reservation)?; } - if !self.zone_mac.is_empty() { - struct_ser.serialize_field("zoneMac", &self.zone_mac)?; + if self.retain_network_reservation { + struct_ser.serialize_field("retainNetworkReservation", &self.retain_network_reservation)?; } - if !self.ips.is_empty() { - struct_ser.serialize_field("ips", &self.ips)?; + if let Some(v) = self.dns_config.as_ref() { + struct_ser.serialize_field("dnsConfig", v)?; } - if self.mtu != 0 { - struct_ser.serialize_field("mtu", &self.mtu)?; + if self.backend != 0 { + let v = ZoneNetworkBackend::try_from(self.backend) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backend)))?; + struct_ser.serialize_field("backend", &v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkInterfaceStatus { +impl<'de> serde::Deserialize<'de> for ZoneNetworkOptionsSpec { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "host_interface", - "hostInterface", - "zone_interface", - "zoneInterface", - "zone_mac", - "zoneMac", - "ips", - "mtu", + "assume_network_reservation", + "assumeNetworkReservation", + "retain_network_reservation", + "retainNetworkReservation", + "dns_config", + "dnsConfig", + "backend", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - HostInterface, - ZoneInterface, - ZoneMac, - Ips, - Mtu, + AssumeNetworkReservation, + RetainNetworkReservation, + DnsConfig, + Backend, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -18991,11 +31265,10 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkInterfaceStatus { E: serde::de::Error, { match value { - "hostInterface" | "host_interface" => Ok(GeneratedField::HostInterface), - "zoneInterface" | "zone_interface" => Ok(GeneratedField::ZoneInterface), - "zoneMac" | "zone_mac" => Ok(GeneratedField::ZoneMac), - "ips" => Ok(GeneratedField::Ips), - "mtu" => Ok(GeneratedField::Mtu), + "assumeNetworkReservation" | "assume_network_reservation" => Ok(GeneratedField::AssumeNetworkReservation), + "retainNetworkReservation" | "retain_network_reservation" => Ok(GeneratedField::RetainNetworkReservation), + "dnsConfig" | "dns_config" => Ok(GeneratedField::DnsConfig), + "backend" => Ok(GeneratedField::Backend), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -19005,70 +31278,60 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkInterfaceStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkInterfaceStatus; + type Value = ZoneNetworkOptionsSpec; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneNetworkInterfaceStatus") + formatter.write_str("struct protect.control.v1.ZoneNetworkOptionsSpec") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut host_interface__ = None; - let mut zone_interface__ = None; - let mut zone_mac__ = None; - let mut ips__ = None; - let mut mtu__ = None; + let mut assume_network_reservation__ = None; + let mut retain_network_reservation__ = None; + let mut dns_config__ = None; + let mut backend__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::HostInterface => { - if host_interface__.is_some() { - return Err(serde::de::Error::duplicate_field("hostInterface")); - } - host_interface__ = Some(map_.next_value()?); - } - GeneratedField::ZoneInterface => { - if zone_interface__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneInterface")); + GeneratedField::AssumeNetworkReservation => { + if assume_network_reservation__.is_some() { + return Err(serde::de::Error::duplicate_field("assumeNetworkReservation")); } - zone_interface__ = Some(map_.next_value()?); + assume_network_reservation__ = Some(map_.next_value()?); } - GeneratedField::ZoneMac => { - if zone_mac__.is_some() { - return Err(serde::de::Error::duplicate_field("zoneMac")); + GeneratedField::RetainNetworkReservation => { + if retain_network_reservation__.is_some() { + return Err(serde::de::Error::duplicate_field("retainNetworkReservation")); } - zone_mac__ = Some(map_.next_value()?); + retain_network_reservation__ = Some(map_.next_value()?); } - GeneratedField::Ips => { - if ips__.is_some() { - return Err(serde::de::Error::duplicate_field("ips")); + GeneratedField::DnsConfig => { + if dns_config__.is_some() { + return Err(serde::de::Error::duplicate_field("dnsConfig")); } - ips__ = Some(map_.next_value()?); + dns_config__ = map_.next_value()?; } - GeneratedField::Mtu => { - if mtu__.is_some() { - return Err(serde::de::Error::duplicate_field("mtu")); + GeneratedField::Backend => { + if backend__.is_some() { + return Err(serde::de::Error::duplicate_field("backend")); } - mtu__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + backend__ = Some(map_.next_value::()? as i32); } } } - Ok(ZoneNetworkInterfaceStatus { - host_interface: host_interface__.unwrap_or_default(), - zone_interface: zone_interface__.unwrap_or_default(), - zone_mac: zone_mac__.unwrap_or_default(), - ips: ips__.unwrap_or_default(), - mtu: mtu__.unwrap_or_default(), + Ok(ZoneNetworkOptionsSpec { + assume_network_reservation: assume_network_reservation__.unwrap_or_default(), + retain_network_reservation: retain_network_reservation__.unwrap_or_default(), + dns_config: dns_config__, + backend: backend__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneNetworkInterfaceStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneNetworkOptionsSpec", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkIp { +impl serde::Serialize for ZoneNetworkRoute { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -19079,28 +31342,70 @@ impl serde::Serialize for ZoneNetworkIp { if self.version != 0 { len += 1; } - if !self.address.is_empty() { + if !self.source.is_empty() { + len += 1; + } + if !self.destination.is_empty() { len += 1; } if !self.gateway.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkIp", len)?; + if !self.output_interface.is_empty() { + len += 1; + } + if self.scope != 0 { + len += 1; + } + if self.table != 0 { + len += 1; + } + if self.protocol != 0 { + len += 1; + } + if self.kind != 0 { + len += 1; + } + if !self.pref_source.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkRoute", len)?; if self.version != 0 { let v = ZoneNetworkIpVersion::try_from(self.version) .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?; struct_ser.serialize_field("version", &v)?; } - if !self.address.is_empty() { - struct_ser.serialize_field("address", &self.address)?; + if !self.source.is_empty() { + struct_ser.serialize_field("source", &self.source)?; + } + if !self.destination.is_empty() { + struct_ser.serialize_field("destination", &self.destination)?; } if !self.gateway.is_empty() { struct_ser.serialize_field("gateway", &self.gateway)?; } + if !self.output_interface.is_empty() { + struct_ser.serialize_field("outputInterface", &self.output_interface)?; + } + if self.scope != 0 { + struct_ser.serialize_field("scope", &self.scope)?; + } + if self.table != 0 { + struct_ser.serialize_field("table", &self.table)?; + } + if self.protocol != 0 { + struct_ser.serialize_field("protocol", &self.protocol)?; + } + if self.kind != 0 { + struct_ser.serialize_field("kind", &self.kind)?; + } + if !self.pref_source.is_empty() { + struct_ser.serialize_field("prefSource", &self.pref_source)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkIp { +impl<'de> serde::Deserialize<'de> for ZoneNetworkRoute { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where @@ -19108,15 +31413,31 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkIp { { const FIELDS: &[&str] = &[ "version", - "address", + "source", + "destination", "gateway", + "output_interface", + "outputInterface", + "scope", + "table", + "protocol", + "kind", + "pref_source", + "prefSource", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Version, - Address, + Source, + Destination, Gateway, + OutputInterface, + Scope, + Table, + Protocol, + Kind, + PrefSource, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -19139,8 +31460,15 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkIp { { match value { "version" => Ok(GeneratedField::Version), - "address" => Ok(GeneratedField::Address), + "source" => Ok(GeneratedField::Source), + "destination" => Ok(GeneratedField::Destination), "gateway" => Ok(GeneratedField::Gateway), + "outputInterface" | "output_interface" => Ok(GeneratedField::OutputInterface), + "scope" => Ok(GeneratedField::Scope), + "table" => Ok(GeneratedField::Table), + "protocol" => Ok(GeneratedField::Protocol), + "kind" => Ok(GeneratedField::Kind), + "prefSource" | "pref_source" => Ok(GeneratedField::PrefSource), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -19150,19 +31478,26 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkIp { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkIp; + type Value = ZoneNetworkRoute; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneNetworkIp") + formatter.write_str("struct protect.control.v1.ZoneNetworkRoute") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { let mut version__ = None; - let mut address__ = None; + let mut source__ = None; + let mut destination__ = None; let mut gateway__ = None; + let mut output_interface__ = None; + let mut scope__ = None; + let mut table__ = None; + let mut protocol__ = None; + let mut kind__ = None; + let mut pref_source__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Version => { @@ -19171,11 +31506,17 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkIp { } version__ = Some(map_.next_value::()? as i32); } - GeneratedField::Address => { - if address__.is_some() { - return Err(serde::de::Error::duplicate_field("address")); + GeneratedField::Source => { + if source__.is_some() { + return Err(serde::de::Error::duplicate_field("source")); } - address__ = Some(map_.next_value()?); + source__ = Some(map_.next_value()?); + } + GeneratedField::Destination => { + if destination__.is_some() { + return Err(serde::de::Error::duplicate_field("destination")); + } + destination__ = Some(map_.next_value()?); } GeneratedField::Gateway => { if gateway__.is_some() { @@ -19183,122 +31524,222 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkIp { } gateway__ = Some(map_.next_value()?); } + GeneratedField::OutputInterface => { + if output_interface__.is_some() { + return Err(serde::de::Error::duplicate_field("outputInterface")); + } + output_interface__ = Some(map_.next_value()?); + } + GeneratedField::Scope => { + if scope__.is_some() { + return Err(serde::de::Error::duplicate_field("scope")); + } + scope__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Table => { + if table__.is_some() { + return Err(serde::de::Error::duplicate_field("table")); + } + table__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Protocol => { + if protocol__.is_some() { + return Err(serde::de::Error::duplicate_field("protocol")); + } + protocol__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Kind => { + if kind__.is_some() { + return Err(serde::de::Error::duplicate_field("kind")); + } + kind__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::PrefSource => { + if pref_source__.is_some() { + return Err(serde::de::Error::duplicate_field("prefSource")); + } + pref_source__ = Some(map_.next_value()?); + } } } - Ok(ZoneNetworkIp { + Ok(ZoneNetworkRoute { version: version__.unwrap_or_default(), - address: address__.unwrap_or_default(), + source: source__.unwrap_or_default(), + destination: destination__.unwrap_or_default(), gateway: gateway__.unwrap_or_default(), + output_interface: output_interface__.unwrap_or_default(), + scope: scope__.unwrap_or_default(), + table: table__.unwrap_or_default(), + protocol: protocol__.unwrap_or_default(), + kind: kind__.unwrap_or_default(), + pref_source: pref_source__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneNetworkIp", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneNetworkRoute", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkIpVersion { +impl serde::Serialize for ZoneNetworkStatus { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Unknown => "ZONE_NETWORK_IP_VERSION_UNKNOWN", - Self::V4 => "ZONE_NETWORK_IP_VERSION_V4", - Self::V6 => "ZONE_NETWORK_IP_VERSION_V6", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.interfaces.is_empty() { + len += 1; + } + if !self.routes.is_empty() { + len += 1; + } + if !self.neighbors.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkStatus", len)?; + if !self.interfaces.is_empty() { + struct_ser.serialize_field("interfaces", &self.interfaces)?; + } + if !self.routes.is_empty() { + struct_ser.serialize_field("routes", &self.routes)?; + } + if !self.neighbors.is_empty() { + struct_ser.serialize_field("neighbors", &self.neighbors)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkIpVersion { +impl<'de> serde::Deserialize<'de> for ZoneNetworkStatus { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ZONE_NETWORK_IP_VERSION_UNKNOWN", - "ZONE_NETWORK_IP_VERSION_V4", - "ZONE_NETWORK_IP_VERSION_V6", + "interfaces", + "routes", + "neighbors", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Interfaces, + Routes, + Neighbors, + } + 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 = ZoneNetworkIpVersion; + 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) - } + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "interfaces" => Ok(GeneratedField::Interfaces), + "routes" => Ok(GeneratedField::Routes), + "neighbors" => Ok(GeneratedField::Neighbors), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneNetworkStatus; - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneNetworkStatus") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "ZONE_NETWORK_IP_VERSION_UNKNOWN" => Ok(ZoneNetworkIpVersion::Unknown), - "ZONE_NETWORK_IP_VERSION_V4" => Ok(ZoneNetworkIpVersion::V4), - "ZONE_NETWORK_IP_VERSION_V6" => Ok(ZoneNetworkIpVersion::V6), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut interfaces__ = None; + let mut routes__ = None; + let mut neighbors__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Interfaces => { + if interfaces__.is_some() { + return Err(serde::de::Error::duplicate_field("interfaces")); + } + interfaces__ = Some(map_.next_value()?); + } + GeneratedField::Routes => { + if routes__.is_some() { + return Err(serde::de::Error::duplicate_field("routes")); + } + routes__ = Some(map_.next_value()?); + } + GeneratedField::Neighbors => { + if neighbors__.is_some() { + return Err(serde::de::Error::duplicate_field("neighbors")); + } + neighbors__ = Some(map_.next_value()?); + } + } } + Ok(ZoneNetworkStatus { + interfaces: interfaces__.unwrap_or_default(), + routes: routes__.unwrap_or_default(), + neighbors: neighbors__.unwrap_or_default(), + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneNetworkStatus", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkNudMode { +impl serde::Serialize for ZonePauseReason { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { let variant = match self { - Self::Permanent => "ZONE_NETWORK_NUD_MODE_PERMANENT", - Self::Noarp => "ZONE_NETWORK_NUD_MODE_NOARP", - Self::Reachable => "ZONE_NETWORK_NUD_MODE_REACHABLE", + Self::Unknown => "ZONE_PAUSE_REASON_UNKNOWN", + Self::Export => "ZONE_PAUSE_REASON_EXPORT", }; serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkNudMode { +impl<'de> serde::Deserialize<'de> for ZonePauseReason { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ZONE_NETWORK_NUD_MODE_PERMANENT", - "ZONE_NETWORK_NUD_MODE_NOARP", - "ZONE_NETWORK_NUD_MODE_REACHABLE", + "ZONE_PAUSE_REASON_UNKNOWN", + "ZONE_PAUSE_REASON_EXPORT", ]; struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkNudMode; + type Value = ZonePauseReason; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(formatter, "expected one of: {:?}", &FIELDS) @@ -19333,9 +31774,8 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkNudMode { E: serde::de::Error, { match value { - "ZONE_NETWORK_NUD_MODE_PERMANENT" => Ok(ZoneNetworkNudMode::Permanent), - "ZONE_NETWORK_NUD_MODE_NOARP" => Ok(ZoneNetworkNudMode::Noarp), - "ZONE_NETWORK_NUD_MODE_REACHABLE" => Ok(ZoneNetworkNudMode::Reachable), + "ZONE_PAUSE_REASON_UNKNOWN" => Ok(ZonePauseReason::Unknown), + "ZONE_PAUSE_REASON_EXPORT" => Ok(ZonePauseReason::Export), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -19343,7 +31783,7 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkNudMode { deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkNeighborEntry { +impl serde::Serialize for ZonePauseStatus { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -19351,77 +31791,39 @@ impl serde::Serialize for ZoneNetworkNeighborEntry { { use serde::ser::SerializeStruct; let mut len = 0; - if self.version != 0 { - len += 1; - } - if !self.ip_address.is_empty() { + if self.reason != 0 { len += 1; } - if !self.link_layer_address.is_empty() { - len += 1; - } - if !self.attached_interface.is_empty() { - len += 1; - } - if self.unreachability_detection != 0 { - len += 1; - } - if self.kind != 0 { + if self.since.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkNeighborEntry", len)?; - if self.version != 0 { - let v = ZoneNetworkIpVersion::try_from(self.version) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?; - struct_ser.serialize_field("version", &v)?; - } - if !self.ip_address.is_empty() { - struct_ser.serialize_field("ipAddress", &self.ip_address)?; - } - if !self.link_layer_address.is_empty() { - struct_ser.serialize_field("linkLayerAddress", &self.link_layer_address)?; - } - if !self.attached_interface.is_empty() { - struct_ser.serialize_field("attachedInterface", &self.attached_interface)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZonePauseStatus", len)?; + if self.reason != 0 { + let v = ZonePauseReason::try_from(self.reason) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.reason)))?; + struct_ser.serialize_field("reason", &v)?; } - if self.unreachability_detection != 0 { - let v = ZoneNetworkNudMode::try_from(self.unreachability_detection) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.unreachability_detection)))?; - struct_ser.serialize_field("unreachabilityDetection", &v)?; - } - if self.kind != 0 { - struct_ser.serialize_field("kind", &self.kind)?; + if let Some(v) = self.since.as_ref() { + struct_ser.serialize_field("since", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkNeighborEntry { +impl<'de> serde::Deserialize<'de> for ZonePauseStatus { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "version", - "ip_address", - "ipAddress", - "link_layer_address", - "linkLayerAddress", - "attached_interface", - "attachedInterface", - "unreachability_detection", - "unreachabilityDetection", - "kind", + "reason", + "since", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Version, - IpAddress, - LinkLayerAddress, - AttachedInterface, - UnreachabilityDetection, - Kind, + Reason, + Since, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -19443,12 +31845,8 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkNeighborEntry { E: serde::de::Error, { match value { - "version" => Ok(GeneratedField::Version), - "ipAddress" | "ip_address" => Ok(GeneratedField::IpAddress), - "linkLayerAddress" | "link_layer_address" => Ok(GeneratedField::LinkLayerAddress), - "attachedInterface" | "attached_interface" => Ok(GeneratedField::AttachedInterface), - "unreachabilityDetection" | "unreachability_detection" => Ok(GeneratedField::UnreachabilityDetection), - "kind" => Ok(GeneratedField::Kind), + "reason" => Ok(GeneratedField::Reason), + "since" => Ok(GeneratedField::Since), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -19458,78 +31856,44 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkNeighborEntry { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkNeighborEntry; + type Value = ZonePauseStatus; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneNetworkNeighborEntry") + formatter.write_str("struct protect.control.v1.ZonePauseStatus") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut version__ = None; - let mut ip_address__ = None; - let mut link_layer_address__ = None; - let mut attached_interface__ = None; - let mut unreachability_detection__ = None; - let mut kind__ = None; + let mut reason__ = None; + let mut since__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Version => { - if version__.is_some() { - return Err(serde::de::Error::duplicate_field("version")); - } - version__ = Some(map_.next_value::()? as i32); - } - GeneratedField::IpAddress => { - if ip_address__.is_some() { - return Err(serde::de::Error::duplicate_field("ipAddress")); - } - ip_address__ = Some(map_.next_value()?); - } - GeneratedField::LinkLayerAddress => { - if link_layer_address__.is_some() { - return Err(serde::de::Error::duplicate_field("linkLayerAddress")); - } - link_layer_address__ = Some(map_.next_value()?); - } - GeneratedField::AttachedInterface => { - if attached_interface__.is_some() { - return Err(serde::de::Error::duplicate_field("attachedInterface")); - } - attached_interface__ = Some(map_.next_value()?); - } - GeneratedField::UnreachabilityDetection => { - if unreachability_detection__.is_some() { - return Err(serde::de::Error::duplicate_field("unreachabilityDetection")); + GeneratedField::Reason => { + if reason__.is_some() { + return Err(serde::de::Error::duplicate_field("reason")); } - unreachability_detection__ = Some(map_.next_value::()? as i32); + reason__ = Some(map_.next_value::()? as i32); } - GeneratedField::Kind => { - if kind__.is_some() { - return Err(serde::de::Error::duplicate_field("kind")); + GeneratedField::Since => { + if since__.is_some() { + return Err(serde::de::Error::duplicate_field("since")); } - kind__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + since__ = map_.next_value()?; } } } - Ok(ZoneNetworkNeighborEntry { - version: version__.unwrap_or_default(), - ip_address: ip_address__.unwrap_or_default(), - link_layer_address: link_layer_address__.unwrap_or_default(), - attached_interface: attached_interface__.unwrap_or_default(), - unreachability_detection: unreachability_detection__.unwrap_or_default(), - kind: kind__.unwrap_or_default(), + Ok(ZonePauseStatus { + reason: reason__.unwrap_or_default(), + since: since__, }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneNetworkNeighborEntry", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZonePauseStatus", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkOptionsDnsSpec { +impl serde::Serialize for ZoneProcess { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -19537,45 +31901,188 @@ impl serde::Serialize for ZoneNetworkOptionsDnsSpec { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.nameservers.is_empty() { + if self.pid != 0 { len += 1; } - if !self.searches.is_empty() { + if self.parent.is_some() { len += 1; } - if !self.options.is_empty() { + if !self.name.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkOptionsDnsSpec", len)?; - if !self.nameservers.is_empty() { - struct_ser.serialize_field("nameservers", &self.nameservers)?; + if self.executable.is_some() { + len += 1; } - if !self.searches.is_empty() { - struct_ser.serialize_field("searches", &self.searches)?; + if self.cwd.is_some() { + len += 1; } - if !self.options.is_empty() { - struct_ser.serialize_field("options", &self.options)?; + if !self.cmdline.is_empty() { + len += 1; + } + if self.start_time != 0 { + len += 1; + } + if self.uid != 0 { + len += 1; + } + if self.gid != 0 { + len += 1; + } + if self.euid != 0 { + len += 1; + } + if self.egid != 0 { + len += 1; + } + if self.kernel { + len += 1; + } + if self.sample.is_some() { + len += 1; + } + if !self.cgroup.is_empty() { + len += 1; + } + if self.saved_uid != 0 { + len += 1; + } + if self.filesystem_uid != 0 { + len += 1; + } + if self.saved_gid != 0 { + len += 1; + } + if self.filesystem_gid != 0 { + len += 1; + } + if !self.groups.is_empty() { + len += 1; + } + if self.capabilities.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneProcess", len)?; + if self.pid != 0 { + struct_ser.serialize_field("pid", &self.pid)?; + } + if let Some(v) = self.parent.as_ref() { + struct_ser.serialize_field("parent", v)?; + } + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if let Some(v) = self.executable.as_ref() { + struct_ser.serialize_field("executable", v)?; + } + if let Some(v) = self.cwd.as_ref() { + struct_ser.serialize_field("cwd", v)?; + } + if !self.cmdline.is_empty() { + struct_ser.serialize_field("cmdline", &self.cmdline)?; + } + if self.start_time != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("startTime", ToString::to_string(&self.start_time).as_str())?; + } + if self.uid != 0 { + struct_ser.serialize_field("uid", &self.uid)?; + } + if self.gid != 0 { + struct_ser.serialize_field("gid", &self.gid)?; + } + if self.euid != 0 { + struct_ser.serialize_field("euid", &self.euid)?; + } + if self.egid != 0 { + struct_ser.serialize_field("egid", &self.egid)?; + } + if self.kernel { + struct_ser.serialize_field("kernel", &self.kernel)?; + } + if let Some(v) = self.sample.as_ref() { + struct_ser.serialize_field("sample", v)?; + } + if !self.cgroup.is_empty() { + struct_ser.serialize_field("cgroup", &self.cgroup)?; + } + if self.saved_uid != 0 { + struct_ser.serialize_field("savedUid", &self.saved_uid)?; + } + if self.filesystem_uid != 0 { + struct_ser.serialize_field("filesystemUid", &self.filesystem_uid)?; + } + if self.saved_gid != 0 { + struct_ser.serialize_field("savedGid", &self.saved_gid)?; + } + if self.filesystem_gid != 0 { + struct_ser.serialize_field("filesystemGid", &self.filesystem_gid)?; + } + if !self.groups.is_empty() { + struct_ser.serialize_field("groups", &self.groups)?; + } + if let Some(v) = self.capabilities.as_ref() { + struct_ser.serialize_field("capabilities", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkOptionsDnsSpec { +impl<'de> serde::Deserialize<'de> for ZoneProcess { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "nameservers", - "searches", - "options", + "pid", + "parent", + "name", + "executable", + "cwd", + "cmdline", + "start_time", + "startTime", + "uid", + "gid", + "euid", + "egid", + "kernel", + "sample", + "cgroup", + "saved_uid", + "savedUid", + "filesystem_uid", + "filesystemUid", + "saved_gid", + "savedGid", + "filesystem_gid", + "filesystemGid", + "groups", + "capabilities", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Nameservers, - Searches, - Options, + Pid, + Parent, + Name, + Executable, + Cwd, + Cmdline, + StartTime, + Uid, + Gid, + Euid, + Egid, + Kernel, + Sample, + Cgroup, + SavedUid, + FilesystemUid, + SavedGid, + FilesystemGid, + Groups, + Capabilities, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -19597,9 +32104,26 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkOptionsDnsSpec { E: serde::de::Error, { match value { - "nameservers" => Ok(GeneratedField::Nameservers), - "searches" => Ok(GeneratedField::Searches), - "options" => Ok(GeneratedField::Options), + "pid" => Ok(GeneratedField::Pid), + "parent" => Ok(GeneratedField::Parent), + "name" => Ok(GeneratedField::Name), + "executable" => Ok(GeneratedField::Executable), + "cwd" => Ok(GeneratedField::Cwd), + "cmdline" => Ok(GeneratedField::Cmdline), + "startTime" | "start_time" => Ok(GeneratedField::StartTime), + "uid" => Ok(GeneratedField::Uid), + "gid" => Ok(GeneratedField::Gid), + "euid" => Ok(GeneratedField::Euid), + "egid" => Ok(GeneratedField::Egid), + "kernel" => Ok(GeneratedField::Kernel), + "sample" => Ok(GeneratedField::Sample), + "cgroup" => Ok(GeneratedField::Cgroup), + "savedUid" | "saved_uid" => Ok(GeneratedField::SavedUid), + "filesystemUid" | "filesystem_uid" => Ok(GeneratedField::FilesystemUid), + "savedGid" | "saved_gid" => Ok(GeneratedField::SavedGid), + "filesystemGid" | "filesystem_gid" => Ok(GeneratedField::FilesystemGid), + "groups" => Ok(GeneratedField::Groups), + "capabilities" => Ok(GeneratedField::Capabilities), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -19609,52 +32133,213 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkOptionsDnsSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkOptionsDnsSpec; + type Value = ZoneProcess; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneNetworkOptionsDnsSpec") + formatter.write_str("struct protect.control.v1.ZoneProcess") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut nameservers__ = None; - let mut searches__ = None; - let mut options__ = None; + let mut pid__ = None; + let mut parent__ = None; + let mut name__ = None; + let mut executable__ = None; + let mut cwd__ = None; + let mut cmdline__ = None; + let mut start_time__ = None; + let mut uid__ = None; + let mut gid__ = None; + let mut euid__ = None; + let mut egid__ = None; + let mut kernel__ = None; + let mut sample__ = None; + let mut cgroup__ = None; + let mut saved_uid__ = None; + let mut filesystem_uid__ = None; + let mut saved_gid__ = None; + let mut filesystem_gid__ = None; + let mut groups__ = None; + let mut capabilities__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Nameservers => { - if nameservers__.is_some() { - return Err(serde::de::Error::duplicate_field("nameservers")); + GeneratedField::Pid => { + if pid__.is_some() { + return Err(serde::de::Error::duplicate_field("pid")); } - nameservers__ = Some(map_.next_value()?); + pid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Searches => { - if searches__.is_some() { - return Err(serde::de::Error::duplicate_field("searches")); + GeneratedField::Parent => { + if parent__.is_some() { + return Err(serde::de::Error::duplicate_field("parent")); } - searches__ = Some(map_.next_value()?); + parent__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; } - GeneratedField::Options => { - if options__.is_some() { - return Err(serde::de::Error::duplicate_field("options")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - options__ = Some(map_.next_value()?); + name__ = Some(map_.next_value()?); + } + GeneratedField::Executable => { + if executable__.is_some() { + return Err(serde::de::Error::duplicate_field("executable")); + } + executable__ = map_.next_value()?; + } + GeneratedField::Cwd => { + if cwd__.is_some() { + return Err(serde::de::Error::duplicate_field("cwd")); + } + cwd__ = map_.next_value()?; + } + GeneratedField::Cmdline => { + if cmdline__.is_some() { + return Err(serde::de::Error::duplicate_field("cmdline")); + } + cmdline__ = Some(map_.next_value()?); + } + GeneratedField::StartTime => { + if start_time__.is_some() { + return Err(serde::de::Error::duplicate_field("startTime")); + } + start_time__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Uid => { + if uid__.is_some() { + return Err(serde::de::Error::duplicate_field("uid")); + } + uid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Gid => { + if gid__.is_some() { + return Err(serde::de::Error::duplicate_field("gid")); + } + gid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Euid => { + if euid__.is_some() { + return Err(serde::de::Error::duplicate_field("euid")); + } + euid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Egid => { + if egid__.is_some() { + return Err(serde::de::Error::duplicate_field("egid")); + } + egid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Kernel => { + if kernel__.is_some() { + return Err(serde::de::Error::duplicate_field("kernel")); + } + kernel__ = Some(map_.next_value()?); + } + GeneratedField::Sample => { + if sample__.is_some() { + return Err(serde::de::Error::duplicate_field("sample")); + } + sample__ = map_.next_value()?; + } + GeneratedField::Cgroup => { + if cgroup__.is_some() { + return Err(serde::de::Error::duplicate_field("cgroup")); + } + cgroup__ = Some(map_.next_value()?); + } + GeneratedField::SavedUid => { + if saved_uid__.is_some() { + return Err(serde::de::Error::duplicate_field("savedUid")); + } + saved_uid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::FilesystemUid => { + if filesystem_uid__.is_some() { + return Err(serde::de::Error::duplicate_field("filesystemUid")); + } + filesystem_uid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::SavedGid => { + if saved_gid__.is_some() { + return Err(serde::de::Error::duplicate_field("savedGid")); + } + saved_gid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::FilesystemGid => { + if filesystem_gid__.is_some() { + return Err(serde::de::Error::duplicate_field("filesystemGid")); + } + filesystem_gid__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Groups => { + if groups__.is_some() { + return Err(serde::de::Error::duplicate_field("groups")); + } + groups__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + GeneratedField::Capabilities => { + if capabilities__.is_some() { + return Err(serde::de::Error::duplicate_field("capabilities")); + } + capabilities__ = map_.next_value()?; } } } - Ok(ZoneNetworkOptionsDnsSpec { - nameservers: nameservers__.unwrap_or_default(), - searches: searches__.unwrap_or_default(), - options: options__.unwrap_or_default(), + Ok(ZoneProcess { + pid: pid__.unwrap_or_default(), + parent: parent__, + name: name__.unwrap_or_default(), + executable: executable__, + cwd: cwd__, + cmdline: cmdline__.unwrap_or_default(), + start_time: start_time__.unwrap_or_default(), + uid: uid__.unwrap_or_default(), + gid: gid__.unwrap_or_default(), + euid: euid__.unwrap_or_default(), + egid: egid__.unwrap_or_default(), + kernel: kernel__.unwrap_or_default(), + sample: sample__, + cgroup: cgroup__.unwrap_or_default(), + saved_uid: saved_uid__.unwrap_or_default(), + filesystem_uid: filesystem_uid__.unwrap_or_default(), + saved_gid: saved_gid__.unwrap_or_default(), + filesystem_gid: filesystem_gid__.unwrap_or_default(), + groups: groups__.unwrap_or_default(), + capabilities: capabilities__, }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneNetworkOptionsDnsSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneProcess", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkOptionsSpec { +impl serde::Serialize for ZoneProcessCapabilities { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -19662,58 +32347,71 @@ impl serde::Serialize for ZoneNetworkOptionsSpec { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.assume_network_reservation.is_empty() { + if self.inheritable != 0 { len += 1; } - if self.retain_network_reservation { + if self.permitted != 0 { len += 1; } - if self.dns_config.is_some() { + if self.effective != 0 { len += 1; } - if self.backend != 0 { + if self.bounding != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkOptionsSpec", len)?; - if !self.assume_network_reservation.is_empty() { - struct_ser.serialize_field("assumeNetworkReservation", &self.assume_network_reservation)?; + if self.ambient != 0 { + len += 1; } - if self.retain_network_reservation { - struct_ser.serialize_field("retainNetworkReservation", &self.retain_network_reservation)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneProcessCapabilities", len)?; + if self.inheritable != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("inheritable", ToString::to_string(&self.inheritable).as_str())?; } - if let Some(v) = self.dns_config.as_ref() { - struct_ser.serialize_field("dnsConfig", v)?; + if self.permitted != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("permitted", ToString::to_string(&self.permitted).as_str())?; } - if self.backend != 0 { - let v = ZoneNetworkBackend::try_from(self.backend) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backend)))?; - struct_ser.serialize_field("backend", &v)?; + if self.effective != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("effective", ToString::to_string(&self.effective).as_str())?; + } + if self.bounding != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("bounding", ToString::to_string(&self.bounding).as_str())?; + } + if self.ambient != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("ambient", ToString::to_string(&self.ambient).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkOptionsSpec { +impl<'de> serde::Deserialize<'de> for ZoneProcessCapabilities { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "assume_network_reservation", - "assumeNetworkReservation", - "retain_network_reservation", - "retainNetworkReservation", - "dns_config", - "dnsConfig", - "backend", + "inheritable", + "permitted", + "effective", + "bounding", + "ambient", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - AssumeNetworkReservation, - RetainNetworkReservation, - DnsConfig, - Backend, + Inheritable, + Permitted, + Effective, + Bounding, + Ambient, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -19735,10 +32433,11 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkOptionsSpec { E: serde::de::Error, { match value { - "assumeNetworkReservation" | "assume_network_reservation" => Ok(GeneratedField::AssumeNetworkReservation), - "retainNetworkReservation" | "retain_network_reservation" => Ok(GeneratedField::RetainNetworkReservation), - "dnsConfig" | "dns_config" => Ok(GeneratedField::DnsConfig), - "backend" => Ok(GeneratedField::Backend), + "inheritable" => Ok(GeneratedField::Inheritable), + "permitted" => Ok(GeneratedField::Permitted), + "effective" => Ok(GeneratedField::Effective), + "bounding" => Ok(GeneratedField::Bounding), + "ambient" => Ok(GeneratedField::Ambient), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -19748,60 +32447,78 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkOptionsSpec { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkOptionsSpec; + type Value = ZoneProcessCapabilities; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneNetworkOptionsSpec") + formatter.write_str("struct protect.control.v1.ZoneProcessCapabilities") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut assume_network_reservation__ = None; - let mut retain_network_reservation__ = None; - let mut dns_config__ = None; - let mut backend__ = None; + let mut inheritable__ = None; + let mut permitted__ = None; + let mut effective__ = None; + let mut bounding__ = None; + let mut ambient__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::AssumeNetworkReservation => { - if assume_network_reservation__.is_some() { - return Err(serde::de::Error::duplicate_field("assumeNetworkReservation")); + GeneratedField::Inheritable => { + if inheritable__.is_some() { + return Err(serde::de::Error::duplicate_field("inheritable")); } - assume_network_reservation__ = Some(map_.next_value()?); + inheritable__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::RetainNetworkReservation => { - if retain_network_reservation__.is_some() { - return Err(serde::de::Error::duplicate_field("retainNetworkReservation")); + GeneratedField::Permitted => { + if permitted__.is_some() { + return Err(serde::de::Error::duplicate_field("permitted")); } - retain_network_reservation__ = Some(map_.next_value()?); + permitted__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::DnsConfig => { - if dns_config__.is_some() { - return Err(serde::de::Error::duplicate_field("dnsConfig")); + GeneratedField::Effective => { + if effective__.is_some() { + return Err(serde::de::Error::duplicate_field("effective")); } - dns_config__ = map_.next_value()?; + effective__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Backend => { - if backend__.is_some() { - return Err(serde::de::Error::duplicate_field("backend")); + GeneratedField::Bounding => { + if bounding__.is_some() { + return Err(serde::de::Error::duplicate_field("bounding")); } - backend__ = Some(map_.next_value::()? as i32); + bounding__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Ambient => { + if ambient__.is_some() { + return Err(serde::de::Error::duplicate_field("ambient")); + } + ambient__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(ZoneNetworkOptionsSpec { - assume_network_reservation: assume_network_reservation__.unwrap_or_default(), - retain_network_reservation: retain_network_reservation__.unwrap_or_default(), - dns_config: dns_config__, - backend: backend__.unwrap_or_default(), + Ok(ZoneProcessCapabilities { + inheritable: inheritable__.unwrap_or_default(), + permitted: permitted__.unwrap_or_default(), + effective: effective__.unwrap_or_default(), + bounding: bounding__.unwrap_or_default(), + ambient: ambient__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneNetworkOptionsSpec", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneProcessCapabilities", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkRoute { +impl serde::Serialize for ZoneProcessSample { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -19809,105 +32526,178 @@ impl serde::Serialize for ZoneNetworkRoute { { use serde::ser::SerializeStruct; let mut len = 0; - if self.version != 0 { + if self.resident != 0 { len += 1; } - if !self.source.is_empty() { + if self.virtual_memory != 0 { len += 1; } - if !self.destination.is_empty() { + if !self.state.is_empty() { len += 1; } - if !self.gateway.is_empty() { + if self.user_time_ms != 0 { len += 1; } - if !self.output_interface.is_empty() { + if self.system_time_ms != 0 { len += 1; } - if self.scope != 0 { + if self.cpu_usage != 0. { len += 1; } - if self.table != 0 { + if self.threads != 0 { len += 1; } - if self.protocol != 0 { + if self.minor_faults != 0 { len += 1; } - if self.kind != 0 { + if self.major_faults != 0 { len += 1; } - if !self.pref_source.is_empty() { + if self.open_files.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkRoute", len)?; - if self.version != 0 { - let v = ZoneNetworkIpVersion::try_from(self.version) - .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?; - struct_ser.serialize_field("version", &v)?; + if self.priority != 0 { + len += 1; + } + if self.nice != 0 { + len += 1; + } + if self.policy != 0 { + len += 1; + } + if self.realtime_priority != 0 { + len += 1; + } + if self.terminal != 0 { + len += 1; + } + if self.session != 0 { + len += 1; + } + if self.process_group != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneProcessSample", len)?; + if self.resident != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("resident", ToString::to_string(&self.resident).as_str())?; + } + if self.virtual_memory != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("virtualMemory", ToString::to_string(&self.virtual_memory).as_str())?; + } + if !self.state.is_empty() { + struct_ser.serialize_field("state", &self.state)?; + } + if self.user_time_ms != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("userTimeMs", ToString::to_string(&self.user_time_ms).as_str())?; + } + if self.system_time_ms != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("systemTimeMs", ToString::to_string(&self.system_time_ms).as_str())?; + } + if self.cpu_usage != 0. { + struct_ser.serialize_field("cpuUsage", &self.cpu_usage)?; + } + if self.threads != 0 { + struct_ser.serialize_field("threads", &self.threads)?; } - if !self.source.is_empty() { - struct_ser.serialize_field("source", &self.source)?; + if self.minor_faults != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("minorFaults", ToString::to_string(&self.minor_faults).as_str())?; } - if !self.destination.is_empty() { - struct_ser.serialize_field("destination", &self.destination)?; + if self.major_faults != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("majorFaults", ToString::to_string(&self.major_faults).as_str())?; } - if !self.gateway.is_empty() { - struct_ser.serialize_field("gateway", &self.gateway)?; + if let Some(v) = self.open_files.as_ref() { + struct_ser.serialize_field("openFiles", v)?; } - if !self.output_interface.is_empty() { - struct_ser.serialize_field("outputInterface", &self.output_interface)?; + if self.priority != 0 { + struct_ser.serialize_field("priority", &self.priority)?; } - if self.scope != 0 { - struct_ser.serialize_field("scope", &self.scope)?; + if self.nice != 0 { + struct_ser.serialize_field("nice", &self.nice)?; } - if self.table != 0 { - struct_ser.serialize_field("table", &self.table)?; + if self.policy != 0 { + struct_ser.serialize_field("policy", &self.policy)?; } - if self.protocol != 0 { - struct_ser.serialize_field("protocol", &self.protocol)?; + if self.realtime_priority != 0 { + struct_ser.serialize_field("realtimePriority", &self.realtime_priority)?; } - if self.kind != 0 { - struct_ser.serialize_field("kind", &self.kind)?; + if self.terminal != 0 { + struct_ser.serialize_field("terminal", &self.terminal)?; } - if !self.pref_source.is_empty() { - struct_ser.serialize_field("prefSource", &self.pref_source)?; + if self.session != 0 { + struct_ser.serialize_field("session", &self.session)?; + } + if self.process_group != 0 { + struct_ser.serialize_field("processGroup", &self.process_group)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkRoute { +impl<'de> serde::Deserialize<'de> for ZoneProcessSample { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "version", - "source", - "destination", - "gateway", - "output_interface", - "outputInterface", - "scope", - "table", - "protocol", - "kind", - "pref_source", - "prefSource", + "resident", + "virtual_memory", + "virtualMemory", + "state", + "user_time_ms", + "userTimeMs", + "system_time_ms", + "systemTimeMs", + "cpu_usage", + "cpuUsage", + "threads", + "minor_faults", + "minorFaults", + "major_faults", + "majorFaults", + "open_files", + "openFiles", + "priority", + "nice", + "policy", + "realtime_priority", + "realtimePriority", + "terminal", + "session", + "process_group", + "processGroup", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Version, - Source, - Destination, - Gateway, - OutputInterface, - Scope, - Table, - Protocol, - Kind, - PrefSource, + Resident, + VirtualMemory, + State, + UserTimeMs, + SystemTimeMs, + CpuUsage, + Threads, + MinorFaults, + MajorFaults, + OpenFiles, + Priority, + Nice, + Policy, + RealtimePriority, + Terminal, + Session, + ProcessGroup, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -19929,16 +32719,23 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkRoute { E: serde::de::Error, { match value { - "version" => Ok(GeneratedField::Version), - "source" => Ok(GeneratedField::Source), - "destination" => Ok(GeneratedField::Destination), - "gateway" => Ok(GeneratedField::Gateway), - "outputInterface" | "output_interface" => Ok(GeneratedField::OutputInterface), - "scope" => Ok(GeneratedField::Scope), - "table" => Ok(GeneratedField::Table), - "protocol" => Ok(GeneratedField::Protocol), - "kind" => Ok(GeneratedField::Kind), - "prefSource" | "pref_source" => Ok(GeneratedField::PrefSource), + "resident" => Ok(GeneratedField::Resident), + "virtualMemory" | "virtual_memory" => Ok(GeneratedField::VirtualMemory), + "state" => Ok(GeneratedField::State), + "userTimeMs" | "user_time_ms" => Ok(GeneratedField::UserTimeMs), + "systemTimeMs" | "system_time_ms" => Ok(GeneratedField::SystemTimeMs), + "cpuUsage" | "cpu_usage" => Ok(GeneratedField::CpuUsage), + "threads" => Ok(GeneratedField::Threads), + "minorFaults" | "minor_faults" => Ok(GeneratedField::MinorFaults), + "majorFaults" | "major_faults" => Ok(GeneratedField::MajorFaults), + "openFiles" | "open_files" => Ok(GeneratedField::OpenFiles), + "priority" => Ok(GeneratedField::Priority), + "nice" => Ok(GeneratedField::Nice), + "policy" => Ok(GeneratedField::Policy), + "realtimePriority" | "realtime_priority" => Ok(GeneratedField::RealtimePriority), + "terminal" => Ok(GeneratedField::Terminal), + "session" => Ok(GeneratedField::Session), + "processGroup" | "process_group" => Ok(GeneratedField::ProcessGroup), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -19948,116 +32745,196 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkRoute { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkRoute; + type Value = ZoneProcessSample; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneNetworkRoute") + formatter.write_str("struct protect.control.v1.ZoneProcessSample") } - fn visit_map(self, mut map_: V) -> std::result::Result + fn visit_map(self, mut map_: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut version__ = None; - let mut source__ = None; - let mut destination__ = None; - let mut gateway__ = None; - let mut output_interface__ = None; - let mut scope__ = None; - let mut table__ = None; - let mut protocol__ = None; - let mut kind__ = None; - let mut pref_source__ = None; + let mut resident__ = None; + let mut virtual_memory__ = None; + let mut state__ = None; + let mut user_time_ms__ = None; + let mut system_time_ms__ = None; + let mut cpu_usage__ = None; + let mut threads__ = None; + let mut minor_faults__ = None; + let mut major_faults__ = None; + let mut open_files__ = None; + let mut priority__ = None; + let mut nice__ = None; + let mut policy__ = None; + let mut realtime_priority__ = None; + let mut terminal__ = None; + let mut session__ = None; + let mut process_group__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Version => { - if version__.is_some() { - return Err(serde::de::Error::duplicate_field("version")); + GeneratedField::Resident => { + if resident__.is_some() { + return Err(serde::de::Error::duplicate_field("resident")); } - version__ = Some(map_.next_value::()? as i32); + resident__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Source => { - if source__.is_some() { - return Err(serde::de::Error::duplicate_field("source")); + GeneratedField::VirtualMemory => { + if virtual_memory__.is_some() { + return Err(serde::de::Error::duplicate_field("virtualMemory")); } - source__ = Some(map_.next_value()?); + virtual_memory__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Destination => { - if destination__.is_some() { - return Err(serde::de::Error::duplicate_field("destination")); + GeneratedField::State => { + if state__.is_some() { + return Err(serde::de::Error::duplicate_field("state")); } - destination__ = Some(map_.next_value()?); + state__ = Some(map_.next_value()?); } - GeneratedField::Gateway => { - if gateway__.is_some() { - return Err(serde::de::Error::duplicate_field("gateway")); + GeneratedField::UserTimeMs => { + if user_time_ms__.is_some() { + return Err(serde::de::Error::duplicate_field("userTimeMs")); } - gateway__ = Some(map_.next_value()?); + user_time_ms__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::OutputInterface => { - if output_interface__.is_some() { - return Err(serde::de::Error::duplicate_field("outputInterface")); + GeneratedField::SystemTimeMs => { + if system_time_ms__.is_some() { + return Err(serde::de::Error::duplicate_field("systemTimeMs")); } - output_interface__ = Some(map_.next_value()?); + system_time_ms__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Scope => { - if scope__.is_some() { - return Err(serde::de::Error::duplicate_field("scope")); + GeneratedField::CpuUsage => { + if cpu_usage__.is_some() { + return Err(serde::de::Error::duplicate_field("cpuUsage")); } - scope__ = + cpu_usage__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Table => { - if table__.is_some() { - return Err(serde::de::Error::duplicate_field("table")); + GeneratedField::Threads => { + if threads__.is_some() { + return Err(serde::de::Error::duplicate_field("threads")); } - table__ = + threads__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Protocol => { - if protocol__.is_some() { - return Err(serde::de::Error::duplicate_field("protocol")); + GeneratedField::MinorFaults => { + if minor_faults__.is_some() { + return Err(serde::de::Error::duplicate_field("minorFaults")); } - protocol__ = + minor_faults__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::Kind => { - if kind__.is_some() { - return Err(serde::de::Error::duplicate_field("kind")); + GeneratedField::MajorFaults => { + if major_faults__.is_some() { + return Err(serde::de::Error::duplicate_field("majorFaults")); } - kind__ = + major_faults__ = Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } - GeneratedField::PrefSource => { - if pref_source__.is_some() { - return Err(serde::de::Error::duplicate_field("prefSource")); + GeneratedField::OpenFiles => { + if open_files__.is_some() { + return Err(serde::de::Error::duplicate_field("openFiles")); } - pref_source__ = Some(map_.next_value()?); + open_files__ = + map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + GeneratedField::Priority => { + if priority__.is_some() { + return Err(serde::de::Error::duplicate_field("priority")); + } + priority__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Nice => { + if nice__.is_some() { + return Err(serde::de::Error::duplicate_field("nice")); + } + nice__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Policy => { + if policy__.is_some() { + return Err(serde::de::Error::duplicate_field("policy")); + } + policy__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::RealtimePriority => { + if realtime_priority__.is_some() { + return Err(serde::de::Error::duplicate_field("realtimePriority")); + } + realtime_priority__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Terminal => { + if terminal__.is_some() { + return Err(serde::de::Error::duplicate_field("terminal")); + } + terminal__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Session => { + if session__.is_some() { + return Err(serde::de::Error::duplicate_field("session")); + } + session__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ProcessGroup => { + if process_group__.is_some() { + return Err(serde::de::Error::duplicate_field("processGroup")); + } + process_group__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(ZoneNetworkRoute { - version: version__.unwrap_or_default(), - source: source__.unwrap_or_default(), - destination: destination__.unwrap_or_default(), - gateway: gateway__.unwrap_or_default(), - output_interface: output_interface__.unwrap_or_default(), - scope: scope__.unwrap_or_default(), - table: table__.unwrap_or_default(), - protocol: protocol__.unwrap_or_default(), - kind: kind__.unwrap_or_default(), - pref_source: pref_source__.unwrap_or_default(), + Ok(ZoneProcessSample { + resident: resident__.unwrap_or_default(), + virtual_memory: virtual_memory__.unwrap_or_default(), + state: state__.unwrap_or_default(), + user_time_ms: user_time_ms__.unwrap_or_default(), + system_time_ms: system_time_ms__.unwrap_or_default(), + cpu_usage: cpu_usage__.unwrap_or_default(), + threads: threads__.unwrap_or_default(), + minor_faults: minor_faults__.unwrap_or_default(), + major_faults: major_faults__.unwrap_or_default(), + open_files: open_files__, + priority: priority__.unwrap_or_default(), + nice: nice__.unwrap_or_default(), + policy: policy__.unwrap_or_default(), + realtime_priority: realtime_priority__.unwrap_or_default(), + terminal: terminal__.unwrap_or_default(), + session: session__.unwrap_or_default(), + process_group: process_group__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneNetworkRoute", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("protect.control.v1.ZoneProcessSample", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ZoneNetworkStatus { +impl serde::Serialize for ZoneProcessTable { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -20065,45 +32942,50 @@ impl serde::Serialize for ZoneNetworkStatus { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.interfaces.is_empty() { + if self.boot_time != 0 { len += 1; } - if !self.routes.is_empty() { + if self.uptime != 0 { len += 1; } - if !self.neighbors.is_empty() { + if !self.processes.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneNetworkStatus", len)?; - if !self.interfaces.is_empty() { - struct_ser.serialize_field("interfaces", &self.interfaces)?; + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneProcessTable", len)?; + if self.boot_time != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("bootTime", ToString::to_string(&self.boot_time).as_str())?; } - if !self.routes.is_empty() { - struct_ser.serialize_field("routes", &self.routes)?; + if self.uptime != 0 { + #[allow(clippy::needless_borrow)] + #[allow(clippy::needless_borrows_for_generic_args)] + struct_ser.serialize_field("uptime", ToString::to_string(&self.uptime).as_str())?; } - if !self.neighbors.is_empty() { - struct_ser.serialize_field("neighbors", &self.neighbors)?; + if !self.processes.is_empty() { + struct_ser.serialize_field("processes", &self.processes)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ZoneNetworkStatus { +impl<'de> serde::Deserialize<'de> for ZoneProcessTable { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "interfaces", - "routes", - "neighbors", + "boot_time", + "bootTime", + "uptime", + "processes", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Interfaces, - Routes, - Neighbors, + BootTime, + Uptime, + Processes, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -20125,9 +33007,9 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkStatus { E: serde::de::Error, { match value { - "interfaces" => Ok(GeneratedField::Interfaces), - "routes" => Ok(GeneratedField::Routes), - "neighbors" => Ok(GeneratedField::Neighbors), + "bootTime" | "boot_time" => Ok(GeneratedField::BootTime), + "uptime" => Ok(GeneratedField::Uptime), + "processes" => Ok(GeneratedField::Processes), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -20137,49 +33019,127 @@ impl<'de> serde::Deserialize<'de> for ZoneNetworkStatus { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneNetworkStatus; + type Value = ZoneProcessTable; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneProcessTable") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut boot_time__ = None; + let mut uptime__ = None; + let mut processes__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::BootTime => { + if boot_time__.is_some() { + return Err(serde::de::Error::duplicate_field("bootTime")); + } + boot_time__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Uptime => { + if uptime__.is_some() { + return Err(serde::de::Error::duplicate_field("uptime")); + } + uptime__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Processes => { + if processes__.is_some() { + return Err(serde::de::Error::duplicate_field("processes")); + } + processes__ = Some(map_.next_value()?); + } + } + } + Ok(ZoneProcessTable { + boot_time: boot_time__.unwrap_or_default(), + uptime: uptime__.unwrap_or_default(), + processes: processes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneProcessTable", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneReplicateMode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Automatic => "ZONE_REPLICATE_MODE_AUTOMATIC", + Self::Fork => "ZONE_REPLICATE_MODE_FORK", + Self::ExportImport => "ZONE_REPLICATE_MODE_EXPORT_IMPORT", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneReplicateMode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_REPLICATE_MODE_AUTOMATIC", + "ZONE_REPLICATE_MODE_FORK", + "ZONE_REPLICATE_MODE_EXPORT_IMPORT", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneReplicateMode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneNetworkStatus") + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) } - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, { - let mut interfaces__ = None; - let mut routes__ = None; - let mut neighbors__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Interfaces => { - if interfaces__.is_some() { - return Err(serde::de::Error::duplicate_field("interfaces")); - } - interfaces__ = Some(map_.next_value()?); - } - GeneratedField::Routes => { - if routes__.is_some() { - return Err(serde::de::Error::duplicate_field("routes")); - } - routes__ = Some(map_.next_value()?); - } - GeneratedField::Neighbors => { - if neighbors__.is_some() { - return Err(serde::de::Error::duplicate_field("neighbors")); - } - neighbors__ = Some(map_.next_value()?); - } - } + match value { + "ZONE_REPLICATE_MODE_AUTOMATIC" => Ok(ZoneReplicateMode::Automatic), + "ZONE_REPLICATE_MODE_FORK" => Ok(ZoneReplicateMode::Fork), + "ZONE_REPLICATE_MODE_EXPORT_IMPORT" => Ok(ZoneReplicateMode::ExportImport), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } - Ok(ZoneNetworkStatus { - interfaces: interfaces__.unwrap_or_default(), - routes: routes__.unwrap_or_default(), - neighbors: neighbors__.unwrap_or_default(), - }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneNetworkStatus", FIELDS, GeneratedVisitor) + deserializer.deserialize_any(GeneratedVisitor) } } impl serde::Serialize for ZoneResourceAdjustmentPolicy { @@ -20374,6 +33334,9 @@ impl serde::Serialize for ZoneResourcesSpec { if self.target_cpus != 0 { len += 1; } + if self.cpus_affinities_set.is_some() { + len += 1; + } if self.adjustment_policy != 0 { len += 1; } @@ -20402,6 +33365,9 @@ impl serde::Serialize for ZoneResourcesSpec { if self.target_cpus != 0 { struct_ser.serialize_field("targetCpus", &self.target_cpus)?; } + if let Some(v) = self.cpus_affinities_set.as_ref() { + struct_ser.serialize_field("cpusAffinitiesSet", v)?; + } if self.adjustment_policy != 0 { let v = ZoneResourceAdjustmentPolicy::try_from(self.adjustment_policy) .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.adjustment_policy)))?; @@ -20429,6 +33395,8 @@ impl<'de> serde::Deserialize<'de> for ZoneResourcesSpec { "minCpus", "target_cpus", "targetCpus", + "cpus_affinities_set", + "cpusAffinitiesSet", "adjustment_policy", "adjustmentPolicy", ]; @@ -20441,6 +33409,7 @@ impl<'de> serde::Deserialize<'de> for ZoneResourcesSpec { MaxCpus, MinCpus, TargetCpus, + CpusAffinitiesSet, AdjustmentPolicy, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -20469,6 +33438,7 @@ impl<'de> serde::Deserialize<'de> for ZoneResourcesSpec { "maxCpus" | "max_cpus" => Ok(GeneratedField::MaxCpus), "minCpus" | "min_cpus" => Ok(GeneratedField::MinCpus), "targetCpus" | "target_cpus" => Ok(GeneratedField::TargetCpus), + "cpusAffinitiesSet" | "cpus_affinities_set" => Ok(GeneratedField::CpusAffinitiesSet), "adjustmentPolicy" | "adjustment_policy" => Ok(GeneratedField::AdjustmentPolicy), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -20495,6 +33465,7 @@ impl<'de> serde::Deserialize<'de> for ZoneResourcesSpec { let mut max_cpus__ = None; let mut min_cpus__ = None; let mut target_cpus__ = None; + let mut cpus_affinities_set__ = None; let mut adjustment_policy__ = None; while let Some(k) = map_.next_key()? { match k { @@ -20546,6 +33517,12 @@ impl<'de> serde::Deserialize<'de> for ZoneResourcesSpec { Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } + GeneratedField::CpusAffinitiesSet => { + if cpus_affinities_set__.is_some() { + return Err(serde::de::Error::duplicate_field("cpusAffinitiesSet")); + } + cpus_affinities_set__ = map_.next_value()?; + } GeneratedField::AdjustmentPolicy => { if adjustment_policy__.is_some() { return Err(serde::de::Error::duplicate_field("adjustmentPolicy")); @@ -20561,6 +33538,7 @@ impl<'de> serde::Deserialize<'de> for ZoneResourcesSpec { max_cpus: max_cpus__.unwrap_or_default(), min_cpus: min_cpus__.unwrap_or_default(), target_cpus: target_cpus__.unwrap_or_default(), + cpus_affinities_set: cpus_affinities_set__, adjustment_policy: adjustment_policy__.unwrap_or_default(), }) } @@ -20843,41 +33821,301 @@ impl<'de> serde::Deserialize<'de> for ZoneScratchDiskSpecStaticBlock { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ZoneScratchDiskSpecStaticBlock; + type Value = ZoneScratchDiskSpecStaticBlock; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneScratchDiskSpecStaticBlock") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut path__ = None; + let mut device__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Path => { + if path__.is_some() { + return Err(serde::de::Error::duplicate_field("path")); + } + path__ = Some(map_.next_value()?); + } + GeneratedField::Device => { + if device__.is_some() { + return Err(serde::de::Error::duplicate_field("device")); + } + device__ = Some(map_.next_value()?); + } + } + } + Ok(ZoneScratchDiskSpecStaticBlock { + path: path__.unwrap_or_default(), + device: device__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneScratchDiskSpecStaticBlock", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneServiceConfig { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.zone_id.is_empty() { + len += 1; + } + if !self.service.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneServiceConfig", len)?; + if !self.zone_id.is_empty() { + struct_ser.serialize_field("zoneId", &self.zone_id)?; + } + if !self.service.is_empty() { + struct_ser.serialize_field("service", &self.service)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneServiceConfig { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "zone_id", + "zoneId", + "service", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ZoneId, + Service, + } + 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 { + "zoneId" | "zone_id" => Ok(GeneratedField::ZoneId), + "service" => Ok(GeneratedField::Service), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneServiceConfig; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneServiceConfig") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut zone_id__ = None; + let mut service__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ZoneId => { + if zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("zoneId")); + } + zone_id__ = Some(map_.next_value()?); + } + GeneratedField::Service => { + if service__.is_some() { + return Err(serde::de::Error::duplicate_field("service")); + } + service__ = Some(map_.next_value()?); + } + } + } + Ok(ZoneServiceConfig { + zone_id: zone_id__.unwrap_or_default(), + service: service__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneServiceConfig", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ZoneSnapshotArch { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "ZONE_SNAPSHOT_ARCH_UNKNOWN", + Self::X8664 => "ZONE_SNAPSHOT_ARCH_X86_64", + Self::Aarch64 => "ZONE_SNAPSHOT_ARCH_AARCH64", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneSnapshotArch { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_SNAPSHOT_ARCH_UNKNOWN", + "ZONE_SNAPSHOT_ARCH_X86_64", + "ZONE_SNAPSHOT_ARCH_AARCH64", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneSnapshotArch; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_SNAPSHOT_ARCH_UNKNOWN" => Ok(ZoneSnapshotArch::Unknown), + "ZONE_SNAPSHOT_ARCH_X86_64" => Ok(ZoneSnapshotArch::X8664), + "ZONE_SNAPSHOT_ARCH_AARCH64" => Ok(ZoneSnapshotArch::Aarch64), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ZoneSnapshotBackend { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "ZONE_SNAPSHOT_BACKEND_UNKNOWN", + Self::XenPv => "ZONE_SNAPSHOT_BACKEND_XEN_PV", + Self::XenPvh => "ZONE_SNAPSHOT_BACKEND_XEN_PVH", + Self::Kvm => "ZONE_SNAPSHOT_BACKEND_KVM", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneSnapshotBackend { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_SNAPSHOT_BACKEND_UNKNOWN", + "ZONE_SNAPSHOT_BACKEND_XEN_PV", + "ZONE_SNAPSHOT_BACKEND_XEN_PVH", + "ZONE_SNAPSHOT_BACKEND_KVM", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneSnapshotBackend; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct protect.control.v1.ZoneScratchDiskSpecStaticBlock") + write!(formatter, "expected one of: {:?}", &FIELDS) } - fn visit_map(self, mut map_: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, { - let mut path__ = None; - let mut device__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Path => { - if path__.is_some() { - return Err(serde::de::Error::duplicate_field("path")); - } - path__ = Some(map_.next_value()?); - } - GeneratedField::Device => { - if device__.is_some() { - return Err(serde::de::Error::duplicate_field("device")); - } - device__ = Some(map_.next_value()?); - } - } + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_SNAPSHOT_BACKEND_UNKNOWN" => Ok(ZoneSnapshotBackend::Unknown), + "ZONE_SNAPSHOT_BACKEND_XEN_PV" => Ok(ZoneSnapshotBackend::XenPv), + "ZONE_SNAPSHOT_BACKEND_XEN_PVH" => Ok(ZoneSnapshotBackend::XenPvh), + "ZONE_SNAPSHOT_BACKEND_KVM" => Ok(ZoneSnapshotBackend::Kvm), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } - Ok(ZoneScratchDiskSpecStaticBlock { - path: path__.unwrap_or_default(), - device: device__.unwrap_or_default(), - }) } } - deserializer.deserialize_struct("protect.control.v1.ZoneScratchDiskSpecStaticBlock", FIELDS, GeneratedVisitor) + deserializer.deserialize_any(GeneratedVisitor) } } impl serde::Serialize for ZoneSpec { @@ -20921,6 +34159,12 @@ impl serde::Serialize for ZoneSpec { if !self.addons.is_empty() { len += 1; } + if !self.fork_parent_zone_id.is_empty() { + len += 1; + } + if self.vm_image.is_some() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneSpec", len)?; if !self.name.is_empty() { struct_ser.serialize_field("name", &self.name)?; @@ -20955,6 +34199,12 @@ impl serde::Serialize for ZoneSpec { if !self.addons.is_empty() { struct_ser.serialize_field("addons", &self.addons)?; } + if !self.fork_parent_zone_id.is_empty() { + struct_ser.serialize_field("forkParentZoneId", &self.fork_parent_zone_id)?; + } + if let Some(v) = self.vm_image.as_ref() { + struct_ser.serialize_field("vmImage", v)?; + } struct_ser.end() } } @@ -20981,6 +34231,10 @@ impl<'de> serde::Deserialize<'de> for ZoneSpec { "scratch_disk", "scratchDisk", "addons", + "fork_parent_zone_id", + "forkParentZoneId", + "vm_image", + "vmImage", ]; #[allow(clippy::enum_variant_names)] @@ -20996,6 +34250,8 @@ impl<'de> serde::Deserialize<'de> for ZoneSpec { VirtualizationOptions, ScratchDisk, Addons, + ForkParentZoneId, + VmImage, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -21028,6 +34284,8 @@ impl<'de> serde::Deserialize<'de> for ZoneSpec { "virtualizationOptions" | "virtualization_options" => Ok(GeneratedField::VirtualizationOptions), "scratchDisk" | "scratch_disk" => Ok(GeneratedField::ScratchDisk), "addons" => Ok(GeneratedField::Addons), + "forkParentZoneId" | "fork_parent_zone_id" => Ok(GeneratedField::ForkParentZoneId), + "vmImage" | "vm_image" => Ok(GeneratedField::VmImage), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -21058,6 +34316,8 @@ impl<'de> serde::Deserialize<'de> for ZoneSpec { let mut virtualization_options__ = None; let mut scratch_disk__ = None; let mut addons__ = None; + let mut fork_parent_zone_id__ = None; + let mut vm_image__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Name => { @@ -21126,6 +34386,18 @@ impl<'de> serde::Deserialize<'de> for ZoneSpec { } addons__ = Some(map_.next_value()?); } + GeneratedField::ForkParentZoneId => { + if fork_parent_zone_id__.is_some() { + return Err(serde::de::Error::duplicate_field("forkParentZoneId")); + } + fork_parent_zone_id__ = Some(map_.next_value()?); + } + GeneratedField::VmImage => { + if vm_image__.is_some() { + return Err(serde::de::Error::duplicate_field("vmImage")); + } + vm_image__ = map_.next_value()?; + } } } Ok(ZoneSpec { @@ -21140,6 +34412,8 @@ impl<'de> serde::Deserialize<'de> for ZoneSpec { virtualization_options: virtualization_options__, scratch_disk: scratch_disk__, addons: addons__.unwrap_or_default(), + fork_parent_zone_id: fork_parent_zone_id__.unwrap_or_default(), + vm_image: vm_image__, }) } } @@ -21160,6 +34434,11 @@ impl serde::Serialize for ZoneState { Self::Destroying => "ZONE_STATE_DESTROYING", Self::Destroyed => "ZONE_STATE_DESTROYED", Self::Failed => "ZONE_STATE_FAILED", + Self::Suspending => "ZONE_STATE_SUSPENDING", + Self::Suspended => "ZONE_STATE_SUSPENDED", + Self::Resuming => "ZONE_STATE_RESUMING", + Self::Forking => "ZONE_STATE_FORKING", + Self::Importing => "ZONE_STATE_IMPORTING", }; serializer.serialize_str(variant) } @@ -21178,6 +34457,11 @@ impl<'de> serde::Deserialize<'de> for ZoneState { "ZONE_STATE_DESTROYING", "ZONE_STATE_DESTROYED", "ZONE_STATE_FAILED", + "ZONE_STATE_SUSPENDING", + "ZONE_STATE_SUSPENDED", + "ZONE_STATE_RESUMING", + "ZONE_STATE_FORKING", + "ZONE_STATE_IMPORTING", ]; struct GeneratedVisitor; @@ -21225,6 +34509,11 @@ impl<'de> serde::Deserialize<'de> for ZoneState { "ZONE_STATE_DESTROYING" => Ok(ZoneState::Destroying), "ZONE_STATE_DESTROYED" => Ok(ZoneState::Destroyed), "ZONE_STATE_FAILED" => Ok(ZoneState::Failed), + "ZONE_STATE_SUSPENDING" => Ok(ZoneState::Suspending), + "ZONE_STATE_SUSPENDED" => Ok(ZoneState::Suspended), + "ZONE_STATE_RESUMING" => Ok(ZoneState::Resuming), + "ZONE_STATE_FORKING" => Ok(ZoneState::Forking), + "ZONE_STATE_IMPORTING" => Ok(ZoneState::Importing), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -21270,6 +34559,9 @@ impl serde::Serialize for ZoneStatus { if self.ready_at.is_some() { len += 1; } + if self.pause_status.is_some() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneStatus", len)?; if self.state != 0 { let v = ZoneState::try_from(self.state) @@ -21303,6 +34595,9 @@ impl serde::Serialize for ZoneStatus { if let Some(v) = self.ready_at.as_ref() { struct_ser.serialize_field("readyAt", v)?; } + if let Some(v) = self.pause_status.as_ref() { + struct_ser.serialize_field("pauseStatus", v)?; + } struct_ser.end() } } @@ -21330,6 +34625,8 @@ impl<'de> serde::Deserialize<'de> for ZoneStatus { "deviceStatus", "ready_at", "readyAt", + "pause_status", + "pauseStatus", ]; #[allow(clippy::enum_variant_names)] @@ -21344,6 +34641,7 @@ impl<'de> serde::Deserialize<'de> for ZoneStatus { CreatedAt, DeviceStatus, ReadyAt, + PauseStatus, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -21375,6 +34673,7 @@ impl<'de> serde::Deserialize<'de> for ZoneStatus { "createdAt" | "created_at" => Ok(GeneratedField::CreatedAt), "deviceStatus" | "device_status" => Ok(GeneratedField::DeviceStatus), "readyAt" | "ready_at" => Ok(GeneratedField::ReadyAt), + "pauseStatus" | "pause_status" => Ok(GeneratedField::PauseStatus), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -21404,6 +34703,7 @@ impl<'de> serde::Deserialize<'de> for ZoneStatus { let mut created_at__ = None; let mut device_status__ = None; let mut ready_at__ = None; + let mut pause_status__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::State => { @@ -21468,6 +34768,12 @@ impl<'de> serde::Deserialize<'de> for ZoneStatus { } ready_at__ = map_.next_value()?; } + GeneratedField::PauseStatus => { + if pause_status__.is_some() { + return Err(serde::de::Error::duplicate_field("pauseStatus")); + } + pause_status__ = map_.next_value()?; + } } } Ok(ZoneStatus { @@ -21481,6 +34787,7 @@ impl<'de> serde::Deserialize<'de> for ZoneStatus { created_at: created_at__, device_status: device_status__, ready_at: ready_at__, + pause_status: pause_status__, }) } } @@ -21498,6 +34805,7 @@ impl serde::Serialize for ZoneVirtualizationBackend { Self::Pv => "ZONE_VIRTUALIZATION_BACKEND_PV", Self::Pvh => "ZONE_VIRTUALIZATION_BACKEND_PVH", Self::Automatic => "ZONE_VIRTUALIZATION_BACKEND_AUTOMATIC", + Self::Kvm => "ZONE_VIRTUALIZATION_BACKEND_KVM", }; serializer.serialize_str(variant) } @@ -21513,6 +34821,7 @@ impl<'de> serde::Deserialize<'de> for ZoneVirtualizationBackend { "ZONE_VIRTUALIZATION_BACKEND_PV", "ZONE_VIRTUALIZATION_BACKEND_PVH", "ZONE_VIRTUALIZATION_BACKEND_AUTOMATIC", + "ZONE_VIRTUALIZATION_BACKEND_KVM", ]; struct GeneratedVisitor; @@ -21557,6 +34866,7 @@ impl<'de> serde::Deserialize<'de> for ZoneVirtualizationBackend { "ZONE_VIRTUALIZATION_BACKEND_PV" => Ok(ZoneVirtualizationBackend::Pv), "ZONE_VIRTUALIZATION_BACKEND_PVH" => Ok(ZoneVirtualizationBackend::Pvh), "ZONE_VIRTUALIZATION_BACKEND_AUTOMATIC" => Ok(ZoneVirtualizationBackend::Automatic), + "ZONE_VIRTUALIZATION_BACKEND_KVM" => Ok(ZoneVirtualizationBackend::Kvm), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -21575,12 +34885,26 @@ impl serde::Serialize for ZoneVirtualizationOptionsSpec { if self.backend != 0 { len += 1; } + if self.numa_nodes != 0 { + len += 1; + } + if self.numa_strategy != 0 { + len += 1; + } let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneVirtualizationOptionsSpec", len)?; if self.backend != 0 { let v = ZoneVirtualizationBackend::try_from(self.backend) .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.backend)))?; struct_ser.serialize_field("backend", &v)?; } + if self.numa_nodes != 0 { + struct_ser.serialize_field("numaNodes", &self.numa_nodes)?; + } + if self.numa_strategy != 0 { + let v = NumaStrategy::try_from(self.numa_strategy) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.numa_strategy)))?; + struct_ser.serialize_field("numaStrategy", &v)?; + } struct_ser.end() } } @@ -21592,11 +34916,17 @@ impl<'de> serde::Deserialize<'de> for ZoneVirtualizationOptionsSpec { { const FIELDS: &[&str] = &[ "backend", + "numa_nodes", + "numaNodes", + "numa_strategy", + "numaStrategy", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Backend, + NumaNodes, + NumaStrategy, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -21619,6 +34949,8 @@ impl<'de> serde::Deserialize<'de> for ZoneVirtualizationOptionsSpec { { match value { "backend" => Ok(GeneratedField::Backend), + "numaNodes" | "numa_nodes" => Ok(GeneratedField::NumaNodes), + "numaStrategy" | "numa_strategy" => Ok(GeneratedField::NumaStrategy), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -21639,6 +34971,8 @@ impl<'de> serde::Deserialize<'de> for ZoneVirtualizationOptionsSpec { V: serde::de::MapAccess<'de>, { let mut backend__ = None; + let mut numa_nodes__ = None; + let mut numa_strategy__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Backend => { @@ -21647,13 +34981,213 @@ impl<'de> serde::Deserialize<'de> for ZoneVirtualizationOptionsSpec { } backend__ = Some(map_.next_value::()? as i32); } + GeneratedField::NumaNodes => { + if numa_nodes__.is_some() { + return Err(serde::de::Error::duplicate_field("numaNodes")); + } + numa_nodes__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::NumaStrategy => { + if numa_strategy__.is_some() { + return Err(serde::de::Error::duplicate_field("numaStrategy")); + } + numa_strategy__ = Some(map_.next_value::()? as i32); + } } } Ok(ZoneVirtualizationOptionsSpec { backend: backend__.unwrap_or_default(), + numa_nodes: numa_nodes__.unwrap_or_default(), + numa_strategy: numa_strategy__.unwrap_or_default(), }) } } deserializer.deserialize_struct("protect.control.v1.ZoneVirtualizationOptionsSpec", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for ZoneVmImageFormat { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unspecified => "ZONE_VM_IMAGE_FORMAT_UNSPECIFIED", + Self::Raw => "ZONE_VM_IMAGE_FORMAT_RAW", + Self::Qcow2 => "ZONE_VM_IMAGE_FORMAT_QCOW2", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ZoneVmImageFormat { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ZONE_VM_IMAGE_FORMAT_UNSPECIFIED", + "ZONE_VM_IMAGE_FORMAT_RAW", + "ZONE_VM_IMAGE_FORMAT_QCOW2", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneVmImageFormat; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ZONE_VM_IMAGE_FORMAT_UNSPECIFIED" => Ok(ZoneVmImageFormat::Unspecified), + "ZONE_VM_IMAGE_FORMAT_RAW" => Ok(ZoneVmImageFormat::Raw), + "ZONE_VM_IMAGE_FORMAT_QCOW2" => Ok(ZoneVmImageFormat::Qcow2), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ZoneVmImageSpec { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.path.is_empty() { + len += 1; + } + if self.format != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("protect.control.v1.ZoneVmImageSpec", len)?; + if !self.path.is_empty() { + struct_ser.serialize_field("path", &self.path)?; + } + if self.format != 0 { + let v = ZoneVmImageFormat::try_from(self.format) + .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?; + struct_ser.serialize_field("format", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ZoneVmImageSpec { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "path", + "format", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Path, + Format, + } + 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 { + "path" => Ok(GeneratedField::Path), + "format" => Ok(GeneratedField::Format), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ZoneVmImageSpec; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct protect.control.v1.ZoneVmImageSpec") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut path__ = None; + let mut format__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Path => { + if path__.is_some() { + return Err(serde::de::Error::duplicate_field("path")); + } + path__ = Some(map_.next_value()?); + } + GeneratedField::Format => { + if format__.is_some() { + return Err(serde::de::Error::duplicate_field("format")); + } + format__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(ZoneVmImageSpec { + path: path__.unwrap_or_default(), + format: format__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("protect.control.v1.ZoneVmImageSpec", FIELDS, GeneratedVisitor) + } +} diff --git a/src/proto/generated/protect/control/v1/protect.control.v1.tonic.rs b/src/proto/generated/protect/control/v1/protect.control.v1.tonic.rs index 7803651..59d1ad3 100644 --- a/src/proto/generated/protect/control/v1/protect.control.v1.tonic.rs +++ b/src/proto/generated/protect/control/v1/protect.control.v1.tonic.rs @@ -142,6 +142,32 @@ pub mod control_service_client { ); self.inner.server_streaming(req, path, codec).await } + pub async fn snoop_control( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/SnoopControl", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("protect.control.v1.ControlService", "SnoopControl"), + ); + self.inner.server_streaming(req, path, codec).await + } pub async fn get_host_cpu_topology( &mut self, request: impl tonic::IntoRequest, @@ -171,6 +197,35 @@ pub mod control_service_client { ); self.inner.unary(req, path, codec).await } + pub async fn get_host_resources( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/GetHostResources", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "GetHostResources", + ), + ); + self.inner.unary(req, path, codec).await + } pub async fn list_devices( &mut self, request: impl tonic::IntoRequest, @@ -340,11 +395,13 @@ pub mod control_service_client { ); self.inner.streaming(req, path, codec).await } - pub async fn remove_image( + pub async fn import_packed_image( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoStreamingRequest< + Message = super::ImportPackedImageRequest, + >, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -357,20 +414,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/RemoveImage", + "/protect.control.v1.ControlService/ImportPackedImage", ); - let mut req = request.into_request(); + let mut req = request.into_streaming_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "RemoveImage"), + GrpcMethod::new( + "protect.control.v1.ControlService", + "ImportPackedImage", + ), ); - self.inner.unary(req, path, codec).await + self.inner.client_streaming(req, path, codec).await } - pub async fn list_images( + pub async fn remove_image( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response>, + tonic::Response, tonic::Status, > { self.inner @@ -383,20 +443,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ListImages", + "/protect.control.v1.ControlService/RemoveImage", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "ListImages"), + GrpcMethod::new("protect.control.v1.ControlService", "RemoveImage"), ); - self.inner.server_streaming(req, path, codec).await + self.inner.unary(req, path, codec).await } - pub async fn create_zone( + pub async fn prune_images( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -409,20 +469,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/CreateZone", + "/protect.control.v1.ControlService/PruneImages", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "CreateZone"), + GrpcMethod::new("protect.control.v1.ControlService", "PruneImages"), ); self.inner.unary(req, path, codec).await } - pub async fn destroy_zone( + pub async fn list_images( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, > { self.inner @@ -435,20 +495,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/DestroyZone", + "/protect.control.v1.ControlService/ListImages", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "DestroyZone"), + GrpcMethod::new("protect.control.v1.ControlService", "ListImages"), ); - self.inner.unary(req, path, codec).await + self.inner.server_streaming(req, path, codec).await } - pub async fn resolve_zone_id( + pub async fn list_kernel_variants( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -461,20 +521,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ResolveZoneId", + "/protect.control.v1.ControlService/ListKernelVariants", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "ResolveZoneId"), + GrpcMethod::new( + "protect.control.v1.ControlService", + "ListKernelVariants", + ), ); self.inner.unary(req, path, codec).await } - pub async fn resolve_zone_ids( + pub async fn create_zone( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -487,22 +550,22 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ResolveZoneIds", + "/protect.control.v1.ControlService/CreateZone", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new( - "protect.control.v1.ControlService", - "ResolveZoneIds", - ), + GrpcMethod::new("protect.control.v1.ControlService", "CreateZone"), ); self.inner.unary(req, path, codec).await } - pub async fn get_zone( + pub async fn destroy_zone( &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result, tonic::Status> { + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { self.inner .ready() .await @@ -513,18 +576,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/GetZone", + "/protect.control.v1.ControlService/DestroyZone", ); let mut req = request.into_request(); req.extensions_mut() - .insert(GrpcMethod::new("protect.control.v1.ControlService", "GetZone")); + .insert( + GrpcMethod::new("protect.control.v1.ControlService", "DestroyZone"), + ); self.inner.unary(req, path, codec).await } - pub async fn list_zones( + pub async fn suspend_zone( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response>, + tonic::Response, tonic::Status, > { self.inner @@ -537,20 +602,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ListZones", + "/protect.control.v1.ControlService/SuspendZone", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "ListZones"), + GrpcMethod::new("protect.control.v1.ControlService", "SuspendZone"), ); - self.inner.server_streaming(req, path, codec).await + self.inner.unary(req, path, codec).await } - pub async fn update_zone_resources( + pub async fn resume_zone( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -563,25 +628,19 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/UpdateZoneResources", + "/protect.control.v1.ControlService/ResumeZone", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new( - "protect.control.v1.ControlService", - "UpdateZoneResources", - ), + GrpcMethod::new("protect.control.v1.ControlService", "ResumeZone"), ); self.inner.unary(req, path, codec).await } - pub async fn configure_zone_network( + pub async fn fork_zone( &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { self.inner .ready() .await @@ -592,25 +651,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ConfigureZoneNetwork", + "/protect.control.v1.ControlService/ForkZone", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new( - "protect.control.v1.ControlService", - "ConfigureZoneNetwork", - ), + GrpcMethod::new("protect.control.v1.ControlService", "ForkZone"), ); self.inner.unary(req, path, codec).await } - pub async fn attach_zone_console( + pub async fn export_zone( &mut self, - request: impl tonic::IntoStreamingRequest< - Message = super::ZoneConsoleRequest, - >, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response>, + tonic::Response>, tonic::Status, > { self.inner @@ -623,25 +677,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/AttachZoneConsole", + "/protect.control.v1.ControlService/ExportZone", ); - let mut req = request.into_streaming_request(); + let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new( - "protect.control.v1.ControlService", - "AttachZoneConsole", - ), + GrpcMethod::new("protect.control.v1.ControlService", "ExportZone"), ); - self.inner.streaming(req, path, codec).await + self.inner.server_streaming(req, path, codec).await } - pub async fn execute_zone_command( + pub async fn import_zone( &mut self, - request: impl tonic::IntoStreamingRequest< - Message = super::ExecuteZoneCommandRequest, - >, + request: impl tonic::IntoStreamingRequest, ) -> std::result::Result< - tonic::Response>, + tonic::Response, tonic::Status, > { self.inner @@ -654,23 +703,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ExecuteZoneCommand", + "/protect.control.v1.ControlService/ImportZone", ); let mut req = request.into_streaming_request(); req.extensions_mut() .insert( - GrpcMethod::new( - "protect.control.v1.ControlService", - "ExecuteZoneCommand", - ), + GrpcMethod::new("protect.control.v1.ControlService", "ImportZone"), ); - self.inner.streaming(req, path, codec).await + self.inner.client_streaming(req, path, codec).await } - pub async fn read_zone_metrics( + pub async fn replicate_zone( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -683,25 +729,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ReadZoneMetrics", + "/protect.control.v1.ControlService/ReplicateZone", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new( - "protect.control.v1.ControlService", - "ReadZoneMetrics", - ), + GrpcMethod::new("protect.control.v1.ControlService", "ReplicateZone"), ); self.inner.unary(req, path, codec).await } - pub async fn monitor_zone_kernel_events( + pub async fn claim_restored_zone( &mut self, - request: impl tonic::IntoStreamingRequest< - Message = super::MonitorZoneKernelEventRequest, - >, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response>, + tonic::Response, tonic::Status, > { self.inner @@ -714,23 +755,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/MonitorZoneKernelEvents", + "/protect.control.v1.ControlService/ClaimRestoredZone", ); - let mut req = request.into_streaming_request(); + let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "protect.control.v1.ControlService", - "MonitorZoneKernelEvents", + "ClaimRestoredZone", ), ); - self.inner.streaming(req, path, codec).await + self.inner.unary(req, path, codec).await } - pub async fn create_workload( + pub async fn start_restored_zone( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -743,23 +784,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/CreateWorkload", + "/protect.control.v1.ControlService/StartRestoredZone", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "protect.control.v1.ControlService", - "CreateWorkload", + "StartRestoredZone", ), ); self.inner.unary(req, path, codec).await } - pub async fn start_workload( + pub async fn adopt_workload( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -772,20 +813,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/StartWorkload", + "/protect.control.v1.ControlService/AdoptWorkload", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "StartWorkload"), + GrpcMethod::new("protect.control.v1.ControlService", "AdoptWorkload"), ); self.inner.unary(req, path, codec).await } - pub async fn stop_workload( + pub async fn resolve_zone_id( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -798,20 +839,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/StopWorkload", + "/protect.control.v1.ControlService/ResolveZoneId", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "StopWorkload"), + GrpcMethod::new("protect.control.v1.ControlService", "ResolveZoneId"), ); self.inner.unary(req, path, codec).await } - pub async fn destroy_workload( + pub async fn resolve_zone_ids( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -824,27 +865,22 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/DestroyWorkload", + "/protect.control.v1.ControlService/ResolveZoneIds", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "protect.control.v1.ControlService", - "DestroyWorkload", + "ResolveZoneIds", ), ); self.inner.unary(req, path, codec).await } - pub async fn attach_workload_console( + pub async fn get_zone( &mut self, - request: impl tonic::IntoStreamingRequest< - Message = super::WorkloadConsoleRequest, - >, - ) -> std::result::Result< - tonic::Response>, - tonic::Status, - > { + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { self.inner .ready() .await @@ -855,23 +891,18 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/AttachWorkloadConsole", + "/protect.control.v1.ControlService/GetZone", ); - let mut req = request.into_streaming_request(); + let mut req = request.into_request(); req.extensions_mut() - .insert( - GrpcMethod::new( - "protect.control.v1.ControlService", - "AttachWorkloadConsole", - ), - ); - self.inner.streaming(req, path, codec).await + .insert(GrpcMethod::new("protect.control.v1.ControlService", "GetZone")); + self.inner.unary(req, path, codec).await } - pub async fn resolve_workload_id( + pub async fn list_zones( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, > { self.inner @@ -884,23 +915,20 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ResolveWorkloadId", + "/protect.control.v1.ControlService/ListZones", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new( - "protect.control.v1.ControlService", - "ResolveWorkloadId", - ), + GrpcMethod::new("protect.control.v1.ControlService", "ListZones"), ); - self.inner.unary(req, path, codec).await + self.inner.server_streaming(req, path, codec).await } - pub async fn resolve_workload_ids( + pub async fn discover_services( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, > { self.inner @@ -913,23 +941,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ResolveWorkloadIds", + "/protect.control.v1.ControlService/DiscoverServices", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "protect.control.v1.ControlService", - "ResolveWorkloadIds", + "DiscoverServices", ), ); - self.inner.unary(req, path, codec).await + self.inner.server_streaming(req, path, codec).await } - pub async fn list_workloads( + pub async fn get_zones_vcpu_infos( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response>, + tonic::Response>, tonic::Status, > { self.inner @@ -942,20 +970,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ListWorkloads", + "/protect.control.v1.ControlService/GetZonesVcpuInfos", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "ListWorkloads"), + GrpcMethod::new( + "protect.control.v1.ControlService", + "GetZonesVcpuInfos", + ), ); self.inner.server_streaming(req, path, codec).await } - pub async fn get_workload( + pub async fn set_zone_vcpu_affinity( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -968,20 +999,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/GetWorkload", + "/protect.control.v1.ControlService/SetZoneVcpuAffinity", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "GetWorkload"), + GrpcMethod::new( + "protect.control.v1.ControlService", + "SetZoneVcpuAffinity", + ), ); self.inner.unary(req, path, codec).await } - pub async fn watch_events( + pub async fn update_zone_resources( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response>, + tonic::Response, tonic::Status, > { self.inner @@ -994,20 +1028,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/WatchEvents", + "/protect.control.v1.ControlService/UpdateZoneResources", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("protect.control.v1.ControlService", "WatchEvents"), + GrpcMethod::new( + "protect.control.v1.ControlService", + "UpdateZoneResources", + ), ); - self.inner.server_streaming(req, path, codec).await + self.inner.unary(req, path, codec).await } - pub async fn read_hypervisor_console( + pub async fn configure_zone_network( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -1020,23 +1057,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/ReadHypervisorConsole", + "/protect.control.v1.ControlService/ConfigureZoneNetwork", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "protect.control.v1.ControlService", - "ReadHypervisorConsole", + "ConfigureZoneNetwork", ), ); self.inner.unary(req, path, codec).await } - pub async fn hypervisor_debug_info( + pub async fn advertise_zone_service( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -1049,23 +1086,23 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/HypervisorDebugInfo", + "/protect.control.v1.ControlService/AdvertiseZoneService", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "protect.control.v1.ControlService", - "HypervisorDebugInfo", + "AdvertiseZoneService", ), ); self.inner.unary(req, path, codec).await } - pub async fn set_host_power_management_policy( + pub async fn unadvertise_zone_service( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -1078,25 +1115,25 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/SetHostPowerManagementPolicy", + "/protect.control.v1.ControlService/UnadvertiseZoneService", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "protect.control.v1.ControlService", - "SetHostPowerManagementPolicy", + "UnadvertiseZoneService", ), ); self.inner.unary(req, path, codec).await } - pub async fn dial_network_socket( + pub async fn attach_zone_console( &mut self, request: impl tonic::IntoStreamingRequest< - Message = super::DialNetworkSocketRequest, + Message = super::ZoneConsoleRequest, >, ) -> std::result::Result< - tonic::Response>, + tonic::Response>, tonic::Status, > { self.inner @@ -1109,370 +1146,1129 @@ pub mod control_service_client { })?; let codec = tonic_prost::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/protect.control.v1.ControlService/DialNetworkSocket", + "/protect.control.v1.ControlService/AttachZoneConsole", ); let mut req = request.into_streaming_request(); req.extensions_mut() .insert( GrpcMethod::new( "protect.control.v1.ControlService", - "DialNetworkSocket", + "AttachZoneConsole", ), ); self.inner.streaming(req, path, codec).await } - } -} -/// Generated server implementations. -pub mod control_service_server { - #![allow( - unused_variables, - dead_code, - missing_docs, - clippy::wildcard_imports, - clippy::let_unit_value, - )] - use tonic::codegen::*; - /// Generated trait containing gRPC methods that should be implemented for use with ControlServiceServer. - #[async_trait] - pub trait ControlService: std::marker::Send + std::marker::Sync + 'static { - async fn get_host_status( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// Server streaming response type for the SnoopIdm method. - type SnoopIdmStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, - > - + std::marker::Send - + 'static; - async fn snoop_idm( - &self, - request: tonic::Request, - ) -> std::result::Result, tonic::Status>; - async fn get_host_cpu_topology( - &self, - request: tonic::Request, + pub async fn execute_zone_command( + &mut self, + request: impl tonic::IntoStreamingRequest< + Message = super::ExecuteZoneCommandRequest, + >, ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, - >; - async fn list_devices( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/ExecuteZoneCommand", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "ExecuteZoneCommand", + ), + ); + self.inner.streaming(req, path, codec).await + } + pub async fn read_zone_metrics( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - async fn create_network_reservation( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/ReadZoneMetrics", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "ReadZoneMetrics", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn monitor_zone_kernel_events( + &mut self, + request: impl tonic::IntoStreamingRequest< + Message = super::MonitorZoneKernelEventRequest, + >, ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, - >; - async fn destroy_network_reservation( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/MonitorZoneKernelEvents", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "MonitorZoneKernelEvents", + ), + ); + self.inner.streaming(req, path, codec).await + } + pub async fn create_workload( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - /// Server streaming response type for the ListNetworkReservations method. - type ListNetworkReservationsStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result< - super::ListNetworkReservationsReply, - tonic::Status, - >, - > - + std::marker::Send - + 'static; - async fn list_network_reservations( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/CreateWorkload", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "CreateWorkload", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn start_workload( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - /// Server streaming response type for the PullImage method. - type PullImageStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, - > - + std::marker::Send - + 'static; - async fn pull_image( - &self, - request: tonic::Request, - ) -> std::result::Result, tonic::Status>; - /// Server streaming response type for the ImportImage method. - type ImportImageStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, - > - + std::marker::Send - + 'static; - async fn import_image( - &self, - request: tonic::Request>, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/StartWorkload", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("protect.control.v1.ControlService", "StartWorkload"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn stop_workload( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - async fn remove_image( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/StopWorkload", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("protect.control.v1.ControlService", "StopWorkload"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn destroy_workload( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - /// Server streaming response type for the ListImages method. - type ListImagesStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, - > - + std::marker::Send - + 'static; - async fn list_images( - &self, - request: tonic::Request, - ) -> std::result::Result, tonic::Status>; - async fn create_zone( - &self, - request: tonic::Request, - ) -> std::result::Result, tonic::Status>; - async fn destroy_zone( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/DestroyWorkload", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "DestroyWorkload", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn update_workload_resources( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - async fn resolve_zone_id( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/UpdateWorkloadResources", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "UpdateWorkloadResources", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn attach_workload_console( + &mut self, + request: impl tonic::IntoStreamingRequest< + Message = super::WorkloadConsoleRequest, + >, ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, - >; - async fn resolve_zone_ids( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/AttachWorkloadConsole", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "AttachWorkloadConsole", + ), + ); + self.inner.streaming(req, path, codec).await + } + pub async fn resolve_workload_id( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - async fn get_zone( - &self, - request: tonic::Request, - ) -> std::result::Result, tonic::Status>; - /// Server streaming response type for the ListZones method. - type ListZonesStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, - > - + std::marker::Send - + 'static; - async fn list_zones( - &self, - request: tonic::Request, - ) -> std::result::Result, tonic::Status>; - async fn update_zone_resources( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/ResolveWorkloadId", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "ResolveWorkloadId", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn resolve_workload_ids( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - async fn configure_zone_network( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/ResolveWorkloadIds", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "ResolveWorkloadIds", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn list_workloads( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// Server streaming response type for the AttachZoneConsole method. - type AttachZoneConsoleStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, - > - + std::marker::Send - + 'static; - async fn attach_zone_console( - &self, - request: tonic::Request>, - ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, - >; - /// Server streaming response type for the ExecuteZoneCommand method. - type ExecuteZoneCommandStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, - > - + std::marker::Send - + 'static; - async fn execute_zone_command( - &self, - request: tonic::Request>, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/ListWorkloads", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("protect.control.v1.ControlService", "ListWorkloads"), + ); + self.inner.server_streaming(req, path, codec).await + } + pub async fn get_workload( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - async fn read_zone_metrics( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/GetWorkload", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("protect.control.v1.ControlService", "GetWorkload"), + ); + self.inner.unary(req, path, codec).await + } + pub async fn watch_events( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, - >; - /// Server streaming response type for the MonitorZoneKernelEvents method. - type MonitorZoneKernelEventsStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result< - super::MonitorZoneKernelEventReply, - tonic::Status, - >, - > - + std::marker::Send - + 'static; - async fn monitor_zone_kernel_events( - &self, - request: tonic::Request< - tonic::Streaming, - >, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/WatchEvents", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("protect.control.v1.ControlService", "WatchEvents"), + ); + self.inner.server_streaming(req, path, codec).await + } + pub async fn read_hypervisor_console( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - async fn create_workload( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/ReadHypervisorConsole", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "ReadHypervisorConsole", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn hypervisor_debug_info( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - async fn start_workload( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/HypervisorDebugInfo", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "HypervisorDebugInfo", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn set_host_power_management_policy( + &mut self, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, - >; - async fn stop_workload( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/SetHostPowerManagementPolicy", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "SetHostPowerManagementPolicy", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn dial_network_socket( + &mut self, + request: impl tonic::IntoStreamingRequest< + Message = super::DialNetworkSocketRequest, + >, ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, - >; - async fn destroy_workload( - &self, - request: tonic::Request, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/DialNetworkSocket", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "DialNetworkSocket", + ), + ); + self.inner.streaming(req, path, codec).await + } + pub async fn dial_object_capability( + &mut self, + request: impl tonic::IntoStreamingRequest< + Message = super::DialObjectCapabilityRequest, + >, ) -> std::result::Result< - tonic::Response, + tonic::Response>, tonic::Status, - >; - /// Server streaming response type for the AttachWorkloadConsole method. - type AttachWorkloadConsoleStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, - > - + std::marker::Send - + 'static; - async fn attach_workload_console( + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/DialObjectCapability", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "DialObjectCapability", + ), + ); + self.inner.streaming(req, path, codec).await + } + pub async fn list_object_capabilities( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic_prost::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/protect.control.v1.ControlService/ListObjectCapabilities", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "protect.control.v1.ControlService", + "ListObjectCapabilities", + ), + ); + self.inner.server_streaming(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod control_service_server { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value, + )] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with ControlServiceServer. + #[async_trait] + pub trait ControlService: std::marker::Send + std::marker::Sync + 'static { + async fn get_host_status( &self, - request: tonic::Request>, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - async fn resolve_workload_id( + /// Server streaming response type for the SnoopIdm method. + type SnoopIdmStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn snoop_idm( &self, - request: tonic::Request, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the SnoopControl method. + type SnoopControlStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn snoop_control( + &self, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - async fn resolve_workload_ids( + async fn get_host_cpu_topology( &self, - request: tonic::Request, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - /// Server streaming response type for the ListWorkloads method. - type ListWorkloadsStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, + async fn get_host_resources( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn list_devices( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn create_network_reservation( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn destroy_network_reservation( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the ListNetworkReservations method. + type ListNetworkReservationsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result< + super::ListNetworkReservationsReply, + tonic::Status, + >, > + std::marker::Send + 'static; - async fn list_workloads( + async fn list_network_reservations( &self, - request: tonic::Request, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - async fn get_workload( + /// Server streaming response type for the PullImage method. + type PullImageStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn pull_image( &self, - request: tonic::Request, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the ImportImage method. + type ImportImageStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn import_image( + &self, + request: tonic::Request>, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - /// Server streaming response type for the WatchEvents method. - type WatchEventsStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, + async fn import_packed_image( + &self, + request: tonic::Request>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn remove_image( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn prune_images( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the ListImages method. + type ListImagesStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, > + std::marker::Send + 'static; - async fn watch_events( + async fn list_images( &self, - request: tonic::Request, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn list_kernel_variants( + &self, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - async fn read_hypervisor_console( + async fn create_zone( &self, - request: tonic::Request, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn destroy_zone( + &self, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - async fn hypervisor_debug_info( + async fn suspend_zone( &self, - request: tonic::Request, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - async fn set_host_power_management_policy( + async fn resume_zone( &self, - request: tonic::Request, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn fork_zone( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the ExportZone method. + type ExportZoneStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn export_zone( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn import_zone( + &self, + request: tonic::Request>, + ) -> std::result::Result, tonic::Status>; + async fn replicate_zone( + &self, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - /// Server streaming response type for the DialNetworkSocket method. - type DialNetworkSocketStream: tonic::codegen::tokio_stream::Stream< - Item = std::result::Result, + async fn claim_restored_zone( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn start_restored_zone( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn adopt_workload( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn resolve_zone_id( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn resolve_zone_ids( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_zone( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the ListZones method. + type ListZonesStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, > + std::marker::Send + 'static; - async fn dial_network_socket( + async fn list_zones( &self, - request: tonic::Request>, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the DiscoverServices method. + type DiscoverServicesStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn discover_services( + &self, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - } - #[derive(Debug)] - pub struct ControlServiceServer { - inner: Arc, - accept_compression_encodings: EnabledCompressionEncodings, - send_compression_encodings: EnabledCompressionEncodings, - max_decoding_message_size: Option, - max_encoding_message_size: Option, - } - impl ControlServiceServer { + /// Server streaming response type for the GetZonesVcpuInfos method. + type GetZonesVcpuInfosStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn get_zones_vcpu_infos( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn set_zone_vcpu_affinity( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn update_zone_resources( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn configure_zone_network( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn advertise_zone_service( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn unadvertise_zone_service( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the AttachZoneConsole method. + type AttachZoneConsoleStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn attach_zone_console( + &self, + request: tonic::Request>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the ExecuteZoneCommand method. + type ExecuteZoneCommandStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn execute_zone_command( + &self, + request: tonic::Request>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn read_zone_metrics( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the MonitorZoneKernelEvents method. + type MonitorZoneKernelEventsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result< + super::MonitorZoneKernelEventReply, + tonic::Status, + >, + > + + std::marker::Send + + 'static; + async fn monitor_zone_kernel_events( + &self, + request: tonic::Request< + tonic::Streaming, + >, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn create_workload( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn start_workload( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn stop_workload( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn destroy_workload( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn update_workload_resources( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the AttachWorkloadConsole method. + type AttachWorkloadConsoleStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn attach_workload_console( + &self, + request: tonic::Request>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn resolve_workload_id( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn resolve_workload_ids( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the ListWorkloads method. + type ListWorkloadsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn list_workloads( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_workload( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the WatchEvents method. + type WatchEventsStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn watch_events( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn read_hypervisor_console( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn hypervisor_debug_info( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn set_host_power_management_policy( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the DialNetworkSocket method. + type DialNetworkSocketStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + std::marker::Send + + 'static; + async fn dial_network_socket( + &self, + request: tonic::Request>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the DialObjectCapability method. + type DialObjectCapabilityStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result< + super::DialObjectCapabilityReply, + tonic::Status, + >, + > + + std::marker::Send + + 'static; + async fn dial_object_capability( + &self, + request: tonic::Request>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the ListObjectCapabilities method. + type ListObjectCapabilitiesStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result< + super::ListObjectCapabilitiesReply, + tonic::Status, + >, + > + + std::marker::Send + + 'static; + async fn list_object_capabilities( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct ControlServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl ControlServiceServer { pub fn new(inner: T) -> Self { Self::from_arc(Arc::new(inner)) } @@ -1542,24 +2338,827 @@ pub mod control_service_server { match req.uri().path() { "/protect.control.v1.ControlService/GetHostStatus" => { #[allow(non_camel_case_types)] - struct GetHostStatusSvc(pub Arc); + struct GetHostStatusSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for GetHostStatusSvc { + type Response = super::GetHostStatusReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_host_status(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetHostStatusSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/SnoopIdm" => { + #[allow(non_camel_case_types)] + struct SnoopIdmSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::ServerStreamingService + for SnoopIdmSvc { + type Response = super::SnoopIdmReply; + type ResponseStream = T::SnoopIdmStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::snoop_idm(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = SnoopIdmSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/SnoopControl" => { + #[allow(non_camel_case_types)] + struct SnoopControlSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::ServerStreamingService + for SnoopControlSvc { + type Response = super::SnoopControlReply; + type ResponseStream = T::SnoopControlStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::snoop_control(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = SnoopControlSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/GetHostCpuTopology" => { + #[allow(non_camel_case_types)] + struct GetHostCpuTopologySvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for GetHostCpuTopologySvc { + type Response = super::GetHostCpuTopologyReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_host_cpu_topology( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetHostCpuTopologySvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/GetHostResources" => { + #[allow(non_camel_case_types)] + struct GetHostResourcesSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for GetHostResourcesSvc { + type Response = super::GetHostResourcesReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_host_resources(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetHostResourcesSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/ListDevices" => { + #[allow(non_camel_case_types)] + struct ListDevicesSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for ListDevicesSvc { + type Response = super::ListDevicesReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_devices(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListDevicesSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/CreateNetworkReservation" => { + #[allow(non_camel_case_types)] + struct CreateNetworkReservationSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for CreateNetworkReservationSvc { + type Response = super::CreateNetworkReservationReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::CreateNetworkReservationRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create_network_reservation( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateNetworkReservationSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/DestroyNetworkReservation" => { + #[allow(non_camel_case_types)] + struct DestroyNetworkReservationSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService< + super::DestroyNetworkReservationRequest, + > for DestroyNetworkReservationSvc { + type Response = super::DestroyNetworkReservationReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::DestroyNetworkReservationRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::destroy_network_reservation( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DestroyNetworkReservationSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/ListNetworkReservations" => { + #[allow(non_camel_case_types)] + struct ListNetworkReservationsSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::ServerStreamingService< + super::ListNetworkReservationsRequest, + > for ListNetworkReservationsSvc { + type Response = super::ListNetworkReservationsReply; + type ResponseStream = T::ListNetworkReservationsStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::ListNetworkReservationsRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_network_reservations( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListNetworkReservationsSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/PullImage" => { + #[allow(non_camel_case_types)] + struct PullImageSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::ServerStreamingService + for PullImageSvc { + type Response = super::PullImageReply; + type ResponseStream = T::PullImageStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::pull_image(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = PullImageSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/ImportImage" => { + #[allow(non_camel_case_types)] + struct ImportImageSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::StreamingService + for ImportImageSvc { + type Response = super::ImportImageReply; + type ResponseStream = T::ImportImageStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + tonic::Streaming, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::import_image(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ImportImageSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/ImportPackedImage" => { + #[allow(non_camel_case_types)] + struct ImportPackedImageSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::ClientStreamingService< + super::ImportPackedImageRequest, + > for ImportPackedImageSvc { + type Response = super::ImportPackedImageReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + tonic::Streaming, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::import_packed_image(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ImportPackedImageSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.client_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/RemoveImage" => { + #[allow(non_camel_case_types)] + struct RemoveImageSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for RemoveImageSvc { + type Response = super::RemoveImageReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::remove_image(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = RemoveImageSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/PruneImages" => { + #[allow(non_camel_case_types)] + struct PruneImagesSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for PruneImagesSvc { + type Response = super::PruneImagesReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::prune_images(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = PruneImagesSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/ListImages" => { + #[allow(non_camel_case_types)] + struct ListImagesSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::ServerStreamingService + for ListImagesSvc { + type Response = super::ListImagesReply; + type ResponseStream = T::ListImagesStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_images(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListImagesSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/ListKernelVariants" => { + #[allow(non_camel_case_types)] + struct ListKernelVariantsSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for ListKernelVariantsSvc { + type Response = super::ListKernelVariantsReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_kernel_variants(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListKernelVariantsSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/CreateZone" => { + #[allow(non_camel_case_types)] + struct CreateZoneSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for CreateZoneSvc { + type Response = super::CreateZoneReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::create_zone(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = CreateZoneSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/DestroyZone" => { + #[allow(non_camel_case_types)] + struct DestroyZoneSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for GetHostStatusSvc { - type Response = super::GetHostStatusReply; + > tonic::server::UnaryService + for DestroyZoneSvc { + type Response = super::DestroyZoneReply; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::get_host_status(&inner, request) - .await + ::destroy_zone(&inner, request).await }; Box::pin(fut) } @@ -1570,7 +3169,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = GetHostStatusSvc(inner); + let method = DestroyZoneSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1586,26 +3185,25 @@ pub mod control_service_server { }; Box::pin(fut) } - "/protect.control.v1.ControlService/SnoopIdm" => { + "/protect.control.v1.ControlService/SuspendZone" => { #[allow(non_camel_case_types)] - struct SnoopIdmSvc(pub Arc); + struct SuspendZoneSvc(pub Arc); impl< T: ControlService, - > tonic::server::ServerStreamingService - for SnoopIdmSvc { - type Response = super::SnoopIdmReply; - type ResponseStream = T::SnoopIdmStream; + > tonic::server::UnaryService + for SuspendZoneSvc { + type Response = super::SuspendZoneReply; type Future = BoxFuture< - tonic::Response, + tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::snoop_idm(&inner, request).await + ::suspend_zone(&inner, request).await }; Box::pin(fut) } @@ -1616,7 +3214,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = SnoopIdmSvc(inner); + let method = SuspendZoneSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1627,34 +3225,30 @@ pub mod control_service_server { max_decoding_message_size, max_encoding_message_size, ); - let res = grpc.server_streaming(method, req).await; + let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } - "/protect.control.v1.ControlService/GetHostCpuTopology" => { + "/protect.control.v1.ControlService/ResumeZone" => { #[allow(non_camel_case_types)] - struct GetHostCpuTopologySvc(pub Arc); + struct ResumeZoneSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for GetHostCpuTopologySvc { - type Response = super::GetHostCpuTopologyReply; + > tonic::server::UnaryService + for ResumeZoneSvc { + type Response = super::ResumeZoneReply; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::get_host_cpu_topology( - &inner, - request, - ) - .await + ::resume_zone(&inner, request).await }; Box::pin(fut) } @@ -1665,7 +3259,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = GetHostCpuTopologySvc(inner); + let method = ResumeZoneSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1681,25 +3275,25 @@ pub mod control_service_server { }; Box::pin(fut) } - "/protect.control.v1.ControlService/ListDevices" => { + "/protect.control.v1.ControlService/ForkZone" => { #[allow(non_camel_case_types)] - struct ListDevicesSvc(pub Arc); + struct ForkZoneSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for ListDevicesSvc { - type Response = super::ListDevicesReply; + > tonic::server::UnaryService + for ForkZoneSvc { + type Response = super::ForkZoneReply; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::list_devices(&inner, request).await + ::fork_zone(&inner, request).await }; Box::pin(fut) } @@ -1710,7 +3304,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = ListDevicesSvc(inner); + let method = ForkZoneSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1726,14 +3320,60 @@ pub mod control_service_server { }; Box::pin(fut) } - "/protect.control.v1.ControlService/CreateNetworkReservation" => { + "/protect.control.v1.ControlService/ExportZone" => { #[allow(non_camel_case_types)] - struct CreateNetworkReservationSvc(pub Arc); + struct ExportZoneSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for CreateNetworkReservationSvc { - type Response = super::CreateNetworkReservationReply; + > tonic::server::ServerStreamingService + for ExportZoneSvc { + type Response = super::ExportZoneReply; + type ResponseStream = T::ExportZoneStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::export_zone(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ExportZoneSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/ImportZone" => { + #[allow(non_camel_case_types)] + struct ImportZoneSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::ClientStreamingService + for ImportZoneSvc { + type Response = super::ImportZoneReply; type Future = BoxFuture< tonic::Response, tonic::Status, @@ -1741,16 +3381,12 @@ pub mod control_service_server { fn call( &mut self, request: tonic::Request< - super::CreateNetworkReservationRequest, + tonic::Streaming, >, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::create_network_reservation( - &inner, - request, - ) - .await + ::import_zone(&inner, request).await }; Box::pin(fut) } @@ -1761,7 +3397,52 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = CreateNetworkReservationSvc(inner); + let method = ImportZoneSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.client_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/ReplicateZone" => { + #[allow(non_camel_case_types)] + struct ReplicateZoneSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for ReplicateZoneSvc { + type Response = super::ReplicateZoneReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::replicate_zone(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ReplicateZoneSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1777,31 +3458,25 @@ pub mod control_service_server { }; Box::pin(fut) } - "/protect.control.v1.ControlService/DestroyNetworkReservation" => { + "/protect.control.v1.ControlService/ClaimRestoredZone" => { #[allow(non_camel_case_types)] - struct DestroyNetworkReservationSvc(pub Arc); + struct ClaimRestoredZoneSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService< - super::DestroyNetworkReservationRequest, - > for DestroyNetworkReservationSvc { - type Response = super::DestroyNetworkReservationReply; + > tonic::server::UnaryService + for ClaimRestoredZoneSvc { + type Response = super::ClaimRestoredZoneReply; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request< - super::DestroyNetworkReservationRequest, - >, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::destroy_network_reservation( - &inner, - request, - ) + ::claim_restored_zone(&inner, request) .await }; Box::pin(fut) @@ -1813,7 +3488,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = DestroyNetworkReservationSvc(inner); + let method = ClaimRestoredZoneSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1829,32 +3504,25 @@ pub mod control_service_server { }; Box::pin(fut) } - "/protect.control.v1.ControlService/ListNetworkReservations" => { + "/protect.control.v1.ControlService/StartRestoredZone" => { #[allow(non_camel_case_types)] - struct ListNetworkReservationsSvc(pub Arc); + struct StartRestoredZoneSvc(pub Arc); impl< T: ControlService, - > tonic::server::ServerStreamingService< - super::ListNetworkReservationsRequest, - > for ListNetworkReservationsSvc { - type Response = super::ListNetworkReservationsReply; - type ResponseStream = T::ListNetworkReservationsStream; + > tonic::server::UnaryService + for StartRestoredZoneSvc { + type Response = super::StartRestoredZoneReply; type Future = BoxFuture< - tonic::Response, + tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request< - super::ListNetworkReservationsRequest, - >, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::list_network_reservations( - &inner, - request, - ) + ::start_restored_zone(&inner, request) .await }; Box::pin(fut) @@ -1866,7 +3534,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = ListNetworkReservationsSvc(inner); + let method = StartRestoredZoneSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1877,31 +3545,30 @@ pub mod control_service_server { max_decoding_message_size, max_encoding_message_size, ); - let res = grpc.server_streaming(method, req).await; + let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } - "/protect.control.v1.ControlService/PullImage" => { + "/protect.control.v1.ControlService/AdoptWorkload" => { #[allow(non_camel_case_types)] - struct PullImageSvc(pub Arc); + struct AdoptWorkloadSvc(pub Arc); impl< T: ControlService, - > tonic::server::ServerStreamingService - for PullImageSvc { - type Response = super::PullImageReply; - type ResponseStream = T::PullImageStream; + > tonic::server::UnaryService + for AdoptWorkloadSvc { + type Response = super::AdoptWorkloadReply; type Future = BoxFuture< - tonic::Response, + tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::pull_image(&inner, request).await + ::adopt_workload(&inner, request).await }; Box::pin(fut) } @@ -1912,7 +3579,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = PullImageSvc(inner); + let method = AdoptWorkloadSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1923,33 +3590,31 @@ pub mod control_service_server { max_decoding_message_size, max_encoding_message_size, ); - let res = grpc.server_streaming(method, req).await; + let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } - "/protect.control.v1.ControlService/ImportImage" => { + "/protect.control.v1.ControlService/ResolveZoneId" => { #[allow(non_camel_case_types)] - struct ImportImageSvc(pub Arc); + struct ResolveZoneIdSvc(pub Arc); impl< T: ControlService, - > tonic::server::StreamingService - for ImportImageSvc { - type Response = super::ImportImageReply; - type ResponseStream = T::ImportImageStream; + > tonic::server::UnaryService + for ResolveZoneIdSvc { + type Response = super::ResolveZoneIdReply; type Future = BoxFuture< - tonic::Response, + tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request< - tonic::Streaming, - >, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::import_image(&inner, request).await + ::resolve_zone_id(&inner, request) + .await }; Box::pin(fut) } @@ -1960,7 +3625,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = ImportImageSvc(inner); + let method = ResolveZoneIdSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1971,30 +3636,31 @@ pub mod control_service_server { max_decoding_message_size, max_encoding_message_size, ); - let res = grpc.streaming(method, req).await; + let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } - "/protect.control.v1.ControlService/RemoveImage" => { + "/protect.control.v1.ControlService/ResolveZoneIds" => { #[allow(non_camel_case_types)] - struct RemoveImageSvc(pub Arc); + struct ResolveZoneIdsSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for RemoveImageSvc { - type Response = super::RemoveImageReply; + > tonic::server::UnaryService + for ResolveZoneIdsSvc { + type Response = super::ResolveZoneIdsReply; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::remove_image(&inner, request).await + ::resolve_zone_ids(&inner, request) + .await }; Box::pin(fut) } @@ -2005,7 +3671,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = RemoveImageSvc(inner); + let method = ResolveZoneIdsSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2021,26 +3687,25 @@ pub mod control_service_server { }; Box::pin(fut) } - "/protect.control.v1.ControlService/ListImages" => { + "/protect.control.v1.ControlService/GetZone" => { #[allow(non_camel_case_types)] - struct ListImagesSvc(pub Arc); + struct GetZoneSvc(pub Arc); impl< T: ControlService, - > tonic::server::ServerStreamingService - for ListImagesSvc { - type Response = super::ListImagesReply; - type ResponseStream = T::ListImagesStream; + > tonic::server::UnaryService + for GetZoneSvc { + type Response = super::GetZoneReply; type Future = BoxFuture< - tonic::Response, + tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::list_images(&inner, request).await + ::get_zone(&inner, request).await }; Box::pin(fut) } @@ -2051,7 +3716,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = ListImagesSvc(inner); + let method = GetZoneSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2062,30 +3727,31 @@ pub mod control_service_server { max_decoding_message_size, max_encoding_message_size, ); - let res = grpc.server_streaming(method, req).await; + let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } - "/protect.control.v1.ControlService/CreateZone" => { + "/protect.control.v1.ControlService/ListZones" => { #[allow(non_camel_case_types)] - struct CreateZoneSvc(pub Arc); + struct ListZonesSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for CreateZoneSvc { - type Response = super::CreateZoneReply; + > tonic::server::ServerStreamingService + for ListZonesSvc { + type Response = super::ListZonesReply; + type ResponseStream = T::ListZonesStream; type Future = BoxFuture< - tonic::Response, + tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::create_zone(&inner, request).await + ::list_zones(&inner, request).await }; Box::pin(fut) } @@ -2096,7 +3762,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = CreateZoneSvc(inner); + let method = ListZonesSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2107,30 +3773,33 @@ pub mod control_service_server { max_decoding_message_size, max_encoding_message_size, ); - let res = grpc.unary(method, req).await; + let res = grpc.server_streaming(method, req).await; Ok(res) }; Box::pin(fut) } - "/protect.control.v1.ControlService/DestroyZone" => { + "/protect.control.v1.ControlService/DiscoverServices" => { #[allow(non_camel_case_types)] - struct DestroyZoneSvc(pub Arc); + struct DiscoverServicesSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for DestroyZoneSvc { - type Response = super::DestroyZoneReply; + > tonic::server::ServerStreamingService< + super::DiscoverServicesRequest, + > for DiscoverServicesSvc { + type Response = super::DiscoverServicesReply; + type ResponseStream = T::DiscoverServicesStream; type Future = BoxFuture< - tonic::Response, + tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::destroy_zone(&inner, request).await + ::discover_services(&inner, request) + .await }; Box::pin(fut) } @@ -2141,7 +3810,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = DestroyZoneSvc(inner); + let method = DiscoverServicesSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2152,30 +3821,32 @@ pub mod control_service_server { max_decoding_message_size, max_encoding_message_size, ); - let res = grpc.unary(method, req).await; + let res = grpc.server_streaming(method, req).await; Ok(res) }; Box::pin(fut) } - "/protect.control.v1.ControlService/ResolveZoneId" => { + "/protect.control.v1.ControlService/GetZonesVcpuInfos" => { #[allow(non_camel_case_types)] - struct ResolveZoneIdSvc(pub Arc); + struct GetZonesVcpuInfosSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for ResolveZoneIdSvc { - type Response = super::ResolveZoneIdReply; + > tonic::server::ServerStreamingService< + super::GetZonesVcpuInfosRequest, + > for GetZonesVcpuInfosSvc { + type Response = super::GetZonesVcpuInfosReply; + type ResponseStream = T::GetZonesVcpuInfosStream; type Future = BoxFuture< - tonic::Response, + tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::resolve_zone_id(&inner, request) + ::get_zones_vcpu_infos(&inner, request) .await }; Box::pin(fut) @@ -2187,7 +3858,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = ResolveZoneIdSvc(inner); + let method = GetZonesVcpuInfosSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2198,30 +3869,33 @@ pub mod control_service_server { max_decoding_message_size, max_encoding_message_size, ); - let res = grpc.unary(method, req).await; + let res = grpc.server_streaming(method, req).await; Ok(res) }; Box::pin(fut) } - "/protect.control.v1.ControlService/ResolveZoneIds" => { + "/protect.control.v1.ControlService/SetZoneVcpuAffinity" => { #[allow(non_camel_case_types)] - struct ResolveZoneIdsSvc(pub Arc); + struct SetZoneVcpuAffinitySvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for ResolveZoneIdsSvc { - type Response = super::ResolveZoneIdsReply; + > tonic::server::UnaryService + for SetZoneVcpuAffinitySvc { + type Response = super::SetZoneVcpuAffinityReply; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::resolve_zone_ids(&inner, request) + ::set_zone_vcpu_affinity( + &inner, + request, + ) .await }; Box::pin(fut) @@ -2233,7 +3907,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = ResolveZoneIdsSvc(inner); + let method = SetZoneVcpuAffinitySvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2249,25 +3923,29 @@ pub mod control_service_server { }; Box::pin(fut) } - "/protect.control.v1.ControlService/GetZone" => { + "/protect.control.v1.ControlService/UpdateZoneResources" => { #[allow(non_camel_case_types)] - struct GetZoneSvc(pub Arc); + struct UpdateZoneResourcesSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for GetZoneSvc { - type Response = super::GetZoneReply; + > tonic::server::UnaryService + for UpdateZoneResourcesSvc { + type Response = super::UpdateZoneResourcesReply; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::get_zone(&inner, request).await + ::update_zone_resources( + &inner, + request, + ) + .await }; Box::pin(fut) } @@ -2278,7 +3956,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = GetZoneSvc(inner); + let method = UpdateZoneResourcesSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2294,26 +3972,29 @@ pub mod control_service_server { }; Box::pin(fut) } - "/protect.control.v1.ControlService/ListZones" => { + "/protect.control.v1.ControlService/ConfigureZoneNetwork" => { #[allow(non_camel_case_types)] - struct ListZonesSvc(pub Arc); + struct ConfigureZoneNetworkSvc(pub Arc); impl< T: ControlService, - > tonic::server::ServerStreamingService - for ListZonesSvc { - type Response = super::ListZonesReply; - type ResponseStream = T::ListZonesStream; + > tonic::server::UnaryService + for ConfigureZoneNetworkSvc { + type Response = super::ConfigureZoneNetworkReply; type Future = BoxFuture< - tonic::Response, + tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::list_zones(&inner, request).await + ::configure_zone_network( + &inner, + request, + ) + .await }; Box::pin(fut) } @@ -2324,7 +4005,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = ListZonesSvc(inner); + let method = ConfigureZoneNetworkSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2335,30 +4016,30 @@ pub mod control_service_server { max_decoding_message_size, max_encoding_message_size, ); - let res = grpc.server_streaming(method, req).await; + let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } - "/protect.control.v1.ControlService/UpdateZoneResources" => { + "/protect.control.v1.ControlService/AdvertiseZoneService" => { #[allow(non_camel_case_types)] - struct UpdateZoneResourcesSvc(pub Arc); + struct AdvertiseZoneServiceSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for UpdateZoneResourcesSvc { - type Response = super::UpdateZoneResourcesReply; + > tonic::server::UnaryService + for AdvertiseZoneServiceSvc { + type Response = super::AdvertiseZoneServiceReply; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::update_zone_resources( + ::advertise_zone_service( &inner, request, ) @@ -2373,7 +4054,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = UpdateZoneResourcesSvc(inner); + let method = AdvertiseZoneServiceSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2389,25 +4070,25 @@ pub mod control_service_server { }; Box::pin(fut) } - "/protect.control.v1.ControlService/ConfigureZoneNetwork" => { + "/protect.control.v1.ControlService/UnadvertiseZoneService" => { #[allow(non_camel_case_types)] - struct ConfigureZoneNetworkSvc(pub Arc); + struct UnadvertiseZoneServiceSvc(pub Arc); impl< T: ControlService, - > tonic::server::UnaryService - for ConfigureZoneNetworkSvc { - type Response = super::ConfigureZoneNetworkReply; + > tonic::server::UnaryService + for UnadvertiseZoneServiceSvc { + type Response = super::UnadvertiseZoneServiceReply; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::configure_zone_network( + ::unadvertise_zone_service( &inner, request, ) @@ -2422,7 +4103,7 @@ pub mod control_service_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let method = ConfigureZoneNetworkSvc(inner); + let method = UnadvertiseZoneServiceSvc(inner); let codec = tonic_prost::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2817,6 +4498,57 @@ pub mod control_service_server { }; Box::pin(fut) } + "/protect.control.v1.ControlService/UpdateWorkloadResources" => { + #[allow(non_camel_case_types)] + struct UpdateWorkloadResourcesSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::UnaryService + for UpdateWorkloadResourcesSvc { + type Response = super::UpdateWorkloadResourcesReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::UpdateWorkloadResourcesRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_workload_resources( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = UpdateWorkloadResourcesSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } "/protect.control.v1.ControlService/AttachWorkloadConsole" => { #[allow(non_camel_case_types)] struct AttachWorkloadConsoleSvc(pub Arc); @@ -3299,6 +5031,109 @@ pub mod control_service_server { }; Box::pin(fut) } + "/protect.control.v1.ControlService/DialObjectCapability" => { + #[allow(non_camel_case_types)] + struct DialObjectCapabilitySvc(pub Arc); + impl< + T: ControlService, + > tonic::server::StreamingService + for DialObjectCapabilitySvc { + type Response = super::DialObjectCapabilityReply; + type ResponseStream = T::DialObjectCapabilityStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + tonic::Streaming, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::dial_object_capability( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DialObjectCapabilitySvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/protect.control.v1.ControlService/ListObjectCapabilities" => { + #[allow(non_camel_case_types)] + struct ListObjectCapabilitiesSvc(pub Arc); + impl< + T: ControlService, + > tonic::server::ServerStreamingService< + super::ListObjectCapabilitiesRequest, + > for ListObjectCapabilitiesSvc { + type Response = super::ListObjectCapabilitiesReply; + type ResponseStream = T::ListObjectCapabilitiesStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_object_capabilities( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = ListObjectCapabilitiesSvc(inner); + let codec = tonic_prost::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } _ => { Box::pin(async move { let mut response = http::Response::new( diff --git a/src/source_plugin/client/edera_client/zone_watcher.rs b/src/source_plugin/client/edera_client/zone_watcher.rs index 79a91bc..a6f38c1 100644 --- a/src/source_plugin/client/edera_client/zone_watcher.rs +++ b/src/source_plugin/client/edera_client/zone_watcher.rs @@ -78,6 +78,10 @@ impl ZoneWatcher { continue; } + Ok(Event::AdvertiseService(_) | Event::UnadvertiseService(_)) => { + continue; + } + Err(error) => { warn!("failed to receive event: {error}"); } diff --git a/src/source_plugin/client/mod.rs b/src/source_plugin/client/mod.rs index 1d243c9..c5730f0 100644 --- a/src/source_plugin/client/mod.rs +++ b/src/source_plugin/client/mod.rs @@ -3,10 +3,11 @@ use async_stream::stream; use crate::proto::generated::protect::control::v1::{ MonitorZoneKernelEventReply, MonitorZoneKernelEventRequest, ZoneKernelEventStreamStop, - ZoneKernelEventStreamUpdate, ZoneState, + ZoneKernelEventStreamUpdate, ZoneKernelSyscallSource, ZoneState, control_service_client::ControlServiceClient, monitor_zone_kernel_event_request::{self as zk_req}, watch_events_reply::Event, + zone_kernel_event_stream_update, }; use edera_client::{client::ControlClientProvider, dial::ControlDialAddress, events::EventStream}; @@ -257,7 +258,11 @@ impl Client { let event = MonitorZoneKernelEventRequest { zone_id: zone_id.clone(), request: Some(zk_req::Request::Update(ZoneKernelEventStreamUpdate { - enabled_syscalls: enabled_syscalls.unwrap_or_default(), + source: Some(zone_kernel_event_stream_update::Source::Syscalls( + ZoneKernelSyscallSource { + enabled_syscalls: enabled_syscalls.unwrap_or_default(), + }, + )), })), }; let stream = Self::input_stream_kernel_events(event, cancel_rx); diff --git a/src/source_plugin/mod.rs b/src/source_plugin/mod.rs index e4dcbe7..d5acdfc 100644 --- a/src/source_plugin/mod.rs +++ b/src/source_plugin/mod.rs @@ -58,6 +58,11 @@ impl EderaSourcePluginInstance { match rx.try_recv() { Ok(event) => { match event.reply { + Some(Reply::Started(started)) => { + debug!("zone kernel event stream started: {started:?}"); + } + // Only a stream that asks for the network source gets these. + Some(Reply::NetworkEvents(_)) => {} Some(Reply::Threadsnap(snap)) => { // We will silently *take* snapshot events here, // filtering them out of the plugin event stream at this point,