handle rules with direction lifetimes

Author: pythops

oryx-tui/src/filter/direction.rs

@@ -82,6 +82,14 @@ impl TrafficDirectionFilter {
         self.selected_direction.clear();
     }
 
+    pub fn is_ingress_loaded(&self) -> bool {
+        self.applied_direction.contains(&TrafficDirection::Ingress)
+    }
+
+    pub fn is_egress_loaded(&self) -> bool {
+        self.applied_direction.contains(&TrafficDirection::Egress)
+    }
+
     pub fn render(&mut self, frame: &mut Frame, block: Rect, is_focused: bool) {
         let layout = Layout::default()
             .direction(Direction::Horizontal)

oryx-tui/src/handler.rs

@@ -75,6 +75,13 @@ pub fn handle_key_events(
                     if app.filter.focused_block == FocusedBlock::Apply {
                         app.filter
                             .update(sender.clone(), app.data_channel_sender.clone())?;
+                        if !app.filter.traffic_direction.is_ingress_loaded() {
+                            app.section.firewall.disable_ingress_rules();
+                        }
+
+                        if !app.filter.traffic_direction.is_egress_loaded() {
+                            app.section.firewall.disable_egress_rules();
+                        }
 
                         app.active_popup = None;
                     }
@@ -172,6 +179,16 @@ pub fn handle_key_events(
             }
         }
 
+        KeyCode::Char(' ') => {
+            if app.section.focused_section == FocusedSection::Firewall {
+                app.section.firewall.load_rule(
+                    sender.clone(),
+                    app.filter.traffic_direction.is_ingress_loaded(),
+                    app.filter.traffic_direction.is_egress_loaded(),
+                )?;
+            }
+        }
+
         KeyCode::Char('s') => {
             let app_packets = app.packets.lock().unwrap();
             if app_packets.is_empty() {

oryx-tui/src/section/firewall.rs

@@ -341,8 +341,59 @@ impl Firewall {
         self.rules.retain(|r| r.name != rule.name);
     }
 
-    pub fn remove_ingress_rules(&mut self) {}
-    pub fn remove_egress_rules(&mut self) {}
+    pub fn disable_ingress_rules(&mut self) {
+        self.rules.iter_mut().for_each(|rule| {
+            if rule.enabled && rule.direction == TrafficDirection::Ingress {
+                rule.enabled = false;
+            }
+        });
+    }
+    pub fn disable_egress_rules(&mut self) {
+        self.rules.iter_mut().for_each(|rule| {
+            if rule.enabled && rule.direction == TrafficDirection::Egress {
+                rule.enabled = false;
+            }
+        });
+    }
+
+    pub fn load_rule(
+        &mut self,
+        sender: kanal::Sender<crate::event::Event>,
+        is_ingress_loaded: bool,
+        is_egress_loaded: bool,
+    ) -> AppResult<()> {
+        if let Some(index) = self.state.selected() {
+            let rule = &mut self.rules[index];
+
+            match rule.direction {
+                TrafficDirection::Ingress => {
+                    if is_ingress_loaded {
+                        rule.enabled = !rule.enabled;
+                        self.ingress_sender.send(rule.clone())?;
+                    } else {
+                        Notification::send(
+                            "Ingress is not loaded.",
+                            crate::notification::NotificationLevel::Warning,
+                            sender.clone(),
+                        )?;
+                    }
+                }
+                TrafficDirection::Egress => {
+                    if is_egress_loaded {
+                        rule.enabled = !rule.enabled;
+                        self.egress_sender.send(rule.clone())?;
+                    } else {
+                        Notification::send(
+                            "Egress is not loaded.",
+                            crate::notification::NotificationLevel::Warning,
+                            sender.clone(),
+                        )?;
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
 
     pub fn handle_keys(
         &mut self,
@@ -430,20 +481,6 @@ impl Firewall {
                     self.add_rule();
                 }
 
-                KeyCode::Char(' ') => {
-                    if let Some(index) = self.state.selected() {
-                        let rule = &mut self.rules[index];
-                        rule.enabled = !rule.enabled;
-
-                        match rule.direction {
-                            TrafficDirection::Ingress => {
-                                self.ingress_sender.send(rule.clone())?;
-                            }
-                            TrafficDirection::Egress => self.egress_sender.send(rule.clone())?,
-                        }
-                    }
-                }
-
                 KeyCode::Char('e') => {
                     if let Some(index) = self.state.selected() {
                         let rule = self.rules[index].clone();