harborshield 0.1.0

A Rust port of Whalewall, to automate management of firewall rules for Docker containers
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use bon::Builder;
use serde::{Deserialize, Deserializer, Serialize};

#[derive(Debug, Clone, Default, Serialize, Builder)]
pub struct ConfigVerdict {
    #[serde(default)]
    #[builder(default)]
    pub chain: String,
    #[serde(default)]
    #[builder(default)]
    pub queue: u16,
    #[serde(default)]
    #[builder(default)]
    pub input_est_queue: u16,
    #[serde(default)]
    #[builder(default)]
    pub output_est_queue: u16,

    #[serde(skip)]
    #[builder(default = false)]
    pub drop: bool,
}
// Custom Deserialize for ConfigVerdict with validation
impl<'de> Deserialize<'de> for ConfigVerdict {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct TempConfigVerdict {
            #[serde(default)]
            chain: String,
            #[serde(default)]
            queue: u16,
            #[serde(default)]
            input_est_queue: u16,
            #[serde(default)]
            output_est_queue: u16,
            #[serde(skip)]
            drop: bool,
        }

        let temp = TempConfigVerdict::deserialize(deserializer)?;

        // Validate verdict configuration
        if !temp.chain.is_empty() && temp.queue != 0 {
            return Err(serde::de::Error::custom(
                super::ValidationError::InvalidFieldValue {
                    field: "verdict".to_string(),
                    reason: "'chain' and 'queue' are mutually exclusive".to_string(),
                    value: format!("chain: '{}', queue: {}", temp.chain, temp.queue),
                    expected_format: Some("Either 'chain' or 'queue', not both".to_string()),
                },
            ));
        }

        if temp.queue == 0 && temp.input_est_queue != 0 {
            return Err(serde::de::Error::custom(
                super::ValidationError::MissingRequiredField {
                    field: "queue".to_string(),
                    context: "verdict with input_est_queue set".to_string(),
                },
            ));
        }

        if temp.queue == 0 && temp.output_est_queue != 0 {
            return Err(serde::de::Error::custom(
                super::ValidationError::MissingRequiredField {
                    field: "queue".to_string(),
                    context: "verdict with output_est_queue set".to_string(),
                },
            ));
        }

        if temp.input_est_queue == 0 && temp.output_est_queue != 0 {
            return Err(serde::de::Error::custom(
                super::ValidationError::InvalidFieldValue {
                    field: "verdict".to_string(),
                    reason: "'input_est_queue' must be set when 'output_est_queue' is set"
                        .to_string(),
                    value: format!("output_est_queue: {}", temp.output_est_queue),
                    expected_format: Some(
                        "Both input_est_queue and output_est_queue, or neither".to_string(),
                    ),
                },
            ));
        }

        if temp.output_est_queue == 0 && temp.input_est_queue != 0 {
            return Err(serde::de::Error::custom(
                super::ValidationError::InvalidFieldValue {
                    field: "verdict".to_string(),
                    reason: "'output_est_queue' must be set when 'input_est_queue' is set"
                        .to_string(),
                    value: format!("input_est_queue: {}", temp.input_est_queue),
                    expected_format: Some(
                        "Both input_est_queue and output_est_queue, or neither".to_string(),
                    ),
                },
            ));
        }

        Ok(ConfigVerdict {
            chain: temp.chain,
            queue: temp.queue,
            input_est_queue: temp.input_est_queue,
            output_est_queue: temp.output_est_queue,
            drop: temp.drop,
        })
    }
}