Generated from perl api.
Signed-off-by: Dietmar Maurer <[email protected]>
---
proxmox-firewall-api-types/Cargo.toml | 5 +-
proxmox-firewall-api-types/src/lib.rs | 3 +-
proxmox-firewall-api-types/src/policy.rs | 151 +++++++++++++++++++++++
3 files changed, 157 insertions(+), 2 deletions(-)
create mode 100644 proxmox-firewall-api-types/src/policy.rs
diff --git a/proxmox-firewall-api-types/Cargo.toml
b/proxmox-firewall-api-types/Cargo.toml
index 515d1efc..3122d813 100644
--- a/proxmox-firewall-api-types/Cargo.toml
+++ b/proxmox-firewall-api-types/Cargo.toml
@@ -9,12 +9,15 @@ license.workspace = true
repository.workspace = true
exclude.workspace = true
+[features]
+enum-fallback = ["dep:proxmox-fixed-string"]
+
[dependencies]
anyhow.workspace = true
regex.workspace = true
-proxmox-fixed-string.workspace = true
serde = { workspace = true, features = [ "derive" ] }
serde_plain = { workspace = true }
proxmox-schema = { workspace = true, features = ["api-macro"] }
proxmox-serde = { workspace = true, features = ["perl"] }
+proxmox-fixed-string = { workspace = true, optional = true }
diff --git a/proxmox-firewall-api-types/src/lib.rs
b/proxmox-firewall-api-types/src/lib.rs
index 7c4a64a7..b8004c76 100644
--- a/proxmox-firewall-api-types/src/lib.rs
+++ b/proxmox-firewall-api-types/src/lib.rs
@@ -1 +1,2 @@
-// TODO: add code here
+mod policy;
+pub use policy::{FirewallFWPolicy, FirewallIOPolicy};
diff --git a/proxmox-firewall-api-types/src/policy.rs
b/proxmox-firewall-api-types/src/policy.rs
new file mode 100644
index 00000000..274fbe20
--- /dev/null
+++ b/proxmox-firewall-api-types/src/policy.rs
@@ -0,0 +1,151 @@
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "enum-fallback")]
+use proxmox_fixed_string::FixedString;
+use proxmox_schema::api;
+
+#[api]
+/// Firewall forward policy.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
+pub enum FirewallFWPolicy {
+ #[serde(rename = "ACCEPT")]
+ #[default]
+ /// ACCEPT.
+ Accept,
+ #[serde(rename = "DROP")]
+ /// DROP.
+ Drop,
+ #[cfg(feature = "enum-fallback")]
+ #[serde(untagged)]
+ /// Unknwon
+ UnknownEnumValue(FixedString),
+}
+serde_plain::derive_display_from_serialize!(FirewallFWPolicy);
+serde_plain::derive_fromstr_from_deserialize!(FirewallFWPolicy);
+
+#[api]
+/// Firewall IO policy.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub enum FirewallIOPolicy {
+ #[serde(rename = "ACCEPT")]
+ /// ACCEPT.
+ Accept,
+ #[serde(rename = "DROP")]
+ /// DROP.
+ Drop,
+ #[serde(rename = "REJECT")]
+ /// REJECT.
+ Reject,
+ #[cfg(feature = "enum-fallback")]
+ #[serde(untagged)]
+ /// Unknwon
+ UnknownEnumValue(FixedString),
+}
+serde_plain::derive_display_from_serialize!(FirewallIOPolicy);
+serde_plain::derive_fromstr_from_deserialize!(FirewallIOPolicy);
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_firewall_fw_policy_default() {
+ assert_eq!(FirewallFWPolicy::default(), FirewallFWPolicy::Accept);
+ }
+
+ #[test]
+ #[cfg(not(feature = "enum-fallback"))]
+ fn test_firewall_fw_policy_serde_invalid() {
+ serde_plain::from_str::<FirewallFWPolicy>("REJECT")
+ .expect_err("REJECT is not valid for FWPolicy");
+ serde_plain::from_str::<FirewallFWPolicy>("accept")
+ .expect_err("lowercase should be invalid");
+ serde_plain::from_str::<FirewallFWPolicy>("").expect_err("empty string
should be invalid");
+ }
+
+ #[test]
+ fn test_firewall_fw_policy_roundtrip() {
+ for policy in [FirewallFWPolicy::Accept, FirewallFWPolicy::Drop] {
+ let serialized =
serde_plain::to_string(&policy).expect("serialize");
+ let parsed: FirewallFWPolicy =
+ serde_plain::from_str(&serialized).expect("roundtrip parse");
+ assert_eq!(policy, parsed);
+ }
+ }
+
+ #[test]
+ fn test_firewall_fw_policy_serde() {
+ let accept = FirewallFWPolicy::Accept;
+ let serialized = serde_plain::to_string(&accept).expect("serialize");
+ assert_eq!(serialized, "ACCEPT");
+
+ let parsed: FirewallFWPolicy =
serde_plain::from_str(&serialized).expect("deserialize");
+ assert_eq!(parsed, accept);
+
+ let drop = FirewallFWPolicy::Drop;
+ let serialized = serde_plain::to_string(&drop).expect("serialize");
+ assert_eq!(serialized, "DROP");
+
+ let parsed: FirewallFWPolicy =
serde_plain::from_str(&serialized).expect("deserialize");
+ assert_eq!(parsed, drop);
+ }
+
+ #[test]
+ #[cfg(feature = "enum-fallback")]
+ fn test_firewall_fw_policy_serde_enum_fallback() {
+ let unknown =
FirewallFWPolicy::UnknownEnumValue(FixedString::new("TEST").unwrap());
+ let serialized = serde_plain::to_string(&unknown).expect("serialize");
+ assert_eq!(serialized, "TEST");
+
+ let parsed: FirewallFWPolicy =
serde_plain::from_str(&serialized).expect("deserialize");
+ assert_eq!(parsed, unknown);
+ }
+
+ #[test]
+ #[cfg(not(feature = "enum-fallback"))]
+ fn test_firewall_io_policy_serde_invalid() {
+ serde_plain::from_str::<FirewallIOPolicy>("ALLOW").expect_err("ALLOW
is not valid");
+
serde_plain::from_str::<FirewallIOPolicy>("drop").expect_err("lowercase should
be invalid");
+ serde_plain::from_str::<FirewallIOPolicy>("").expect_err("empty string
should be invalid");
+ }
+
+ #[test]
+ fn test_firewall_io_policy_roundtrip() {
+ for policy in [
+ FirewallIOPolicy::Accept,
+ FirewallIOPolicy::Drop,
+ FirewallIOPolicy::Reject,
+ ] {
+ let serialized =
serde_plain::to_string(&policy).expect("serialize");
+ let parsed: FirewallIOPolicy =
+ serde_plain::from_str(&serialized).expect("roundtrip parse");
+ assert_eq!(policy, parsed);
+ }
+ }
+
+ #[test]
+ fn test_firewall_io_policy_serde() {
+ for (policy, expected) in [
+ (FirewallIOPolicy::Accept, "ACCEPT"),
+ (FirewallIOPolicy::Drop, "DROP"),
+ (FirewallIOPolicy::Reject, "REJECT"),
+ ] {
+ let serialized =
serde_plain::to_string(&policy).expect("serialize");
+ assert_eq!(serialized, expected);
+
+ let parsed: FirewallIOPolicy =
serde_plain::from_str(&serialized).expect("deserialize");
+ assert_eq!(parsed, policy);
+ }
+ }
+
+ #[test]
+ #[cfg(feature = "enum-fallback")]
+ fn test_firewall_io_policy_serde_enum_fallback() {
+ let unknown =
FirewallIOPolicy::UnknownEnumValue(FixedString::new("TEST").unwrap());
+ let serialized = serde_plain::to_string(&unknown).expect("serialize");
+ assert_eq!(serialized, "TEST");
+
+ let parsed: FirewallIOPolicy =
serde_plain::from_str(&serialized).expect("deserialize");
+ assert_eq!(parsed, unknown);
+ }
+}
--
2.47.3
