Native: Multiple File Setup & File Concatenation

* Multiple Files view with support for concatenate and open each file in
  new tab.
* Add concatenate to session setups types and start sessions with
  concat origin.
* Implementation of scanned directories in backend service.
* Add menu items for scanning directory to find matching files.
* Opening multiple files form both menu and cli will end end up in
  multiple files setup view.
* Refactoring for host service regarding file operations.

Author: AmmarAbouZor

application/apps/indexer/Cargo.toml

@@ -82,6 +82,7 @@ clap = { version = "4", features = ["derive"] }
 egui = "0.33"
 eframe = { version = "0.33", default-features = false }
 rfd = "0.17"
+egui_extras = { version = "0.33", default-features = false }
 egui_table = "0.6"
 egui_plot = "0.34"
 # We don't have direct dependency to winit but we need to specify it here to activate 

application/apps/indexer/gui/application/Cargo.toml

@@ -55,6 +55,7 @@ eframe = { workspace = true, default_features = false, features = [
     "x11",           # To support older Linux distributions (restores one of the default features)
 ] }
 
+egui_extras.workspace = true
 egui_table.workspace = true
 egui_plot.workspace = true
 egui-phosphor = { workspace = true, features = ["regular", "fill"] }

application/apps/indexer/gui/application/src/host/command.rs

@@ -1,5 +1,6 @@
 use std::path::PathBuf;
 
+use stypes::FileFormat;
 use uuid::Uuid;
 
 use crate::host::{
@@ -10,13 +11,30 @@ use crate::host::{
 /// Host commands to be sent from UI to its service.
 #[derive(Debug, Clone)]
 pub enum HostCommand {
+    /// Opens the files, prompting the user with the setup UI
+    /// if multiple files are provided.
     OpenFiles(Vec<PathBuf>),
+    /// Bypasses the setup UI and opens each file in a separate
+    /// session immediately.
+    OpenAsSessions(Vec<PathBuf>),
+    /// Scans a directory for files matching the given format,
+    /// then opens them via [`HostCommand::OpenFiles`].
+    OpenFromDirectory {
+        dir_path: PathBuf,
+        target_format: FileFormat,
+    },
+    /// Concatenate the provided files grouping them via their format.
+    /// This will start a session for text files directly or will open
+    /// session setup for other file formats.
+    ConcatFiles(Vec<(PathBuf, FileFormat)>),
+    /// Opens sessions setup for connection sources.
     ConnectionSessionSetup {
         stream: StreamNames,
         parser: ParserNames,
     },
     StartSession(Box<StartSessionParam>),
     CloseSessionSetup(Uuid),
+    CloseMultiSetup(Uuid),
     Close,
 }
 

application/apps/indexer/gui/application/src/host/common/colors.rs

@@ -0,0 +1,67 @@
+use egui::Color32;
+
+const HIGHLIGHT_COLORS: [ColorPair; 10] = [
+    // Red
+    ColorPair::new(
+        Color32::from_rgb(255, 255, 255),
+        Color32::from_rgb(180, 40, 40),
+    ),
+    // Green
+    ColorPair::new(
+        Color32::from_rgb(255, 255, 255),
+        Color32::from_rgb(40, 160, 40),
+    ),
+    // Blue
+    ColorPair::new(
+        Color32::from_rgb(255, 255, 255),
+        Color32::from_rgb(40, 80, 180),
+    ),
+    // Orange
+    ColorPair::new(Color32::from_rgb(0, 0, 0), Color32::from_rgb(220, 120, 20)),
+    // Purple
+    ColorPair::new(
+        Color32::from_rgb(255, 255, 255),
+        Color32::from_rgb(140, 40, 180),
+    ),
+    // Teal
+    ColorPair::new(Color32::from_rgb(0, 0, 0), Color32::from_rgb(20, 160, 160)),
+    // Pink
+    ColorPair::new(
+        Color32::from_rgb(255, 255, 255),
+        Color32::from_rgb(220, 60, 140),
+    ),
+    // Lime
+    ColorPair::new(Color32::from_rgb(0, 0, 0), Color32::from_rgb(160, 200, 20)),
+    // Brown
+    ColorPair::new(
+        Color32::from_rgb(255, 255, 255),
+        Color32::from_rgb(120, 80, 40),
+    ),
+    // Slate
+    ColorPair::new(
+        Color32::from_rgb(255, 255, 255),
+        Color32::from_rgb(80, 100, 120),
+    ),
+];
+
+#[allow(unused)]
+/// Represents a foreground and background color combination.
+#[derive(Debug, Clone)]
+pub struct ColorPair {
+    /// Foreground color.
+    pub fg: Color32,
+    /// Background color.
+    pub bg: Color32,
+}
+
+impl ColorPair {
+    /// Creates a new [`ColorPair`] with the provided arguments.
+    pub const fn new(fg: Color32, bg: Color32) -> Self {
+        Self { fg, bg }
+    }
+}
+
+/// Returns a list of available highlighting [`ColorPair`]s.
+pub fn highlighting_colors() -> Vec<ColorPair> {
+    HIGHLIGHT_COLORS.to_vec()
+}

application/apps/indexer/gui/application/src/host/common/file_utls.rs

@@ -0,0 +1,18 @@
+/// Formats a byte count into a human-readable string with units (B, KB, MB, GB).
+///
+/// Precision is kept to two decimal places for units larger than bytes.
+pub fn format_file_size(bytes: u64) -> String {
+    const KB: u64 = 1024;
+    const MB: u64 = 1024 * KB;
+    const GB: u64 = 1024 * MB;
+
+    if bytes < KB {
+        format!("{} B", bytes)
+    } else if bytes < MB {
+        format!("{:.2} KB", bytes as f64 / KB as f64)
+    } else if bytes < GB {
+        format!("{:.2} MB", bytes as f64 / MB as f64)
+    } else {
+        format!("{:.2} GB", bytes as f64 / GB as f64)
+    }
+}

application/apps/indexer/gui/application/src/host/common/mod.rs

@@ -1,2 +1,5 @@
+pub mod colors;
+pub mod file_utls;
 pub mod parsers;
 pub mod sources;
+pub mod ui_utls;

application/apps/indexer/gui/application/src/host/common/parsers.rs

@@ -1,6 +1,6 @@
 use std::fmt::Display;
 
-use stypes::ParserType;
+use stypes::{FileFormat, ParserType};
 
 use crate::host::{common::sources::StreamNames, ui::session_setup::state::parsers::ParserConfig};
 
@@ -45,7 +45,16 @@ impl ParserNames {
         }
     }
 
-    pub const fn is_compatible(self, stream: StreamNames) -> bool {
+    pub const fn is_compatible_file(self, format: FileFormat) -> bool {
+        match format {
+            FileFormat::PcapNG | FileFormat::PcapLegacy | FileFormat::Binary => {
+                self.support_binary_files()
+            }
+            FileFormat::Text => self.support_text_files(),
+        }
+    }
+
+    pub const fn is_compatible_stream(self, stream: StreamNames) -> bool {
         use ParserNames as Parser;
         use StreamNames as Stream;
 
@@ -93,3 +102,74 @@ impl From<&ParserConfig> for ParserNames {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use stypes::FileFormat;
+
+    #[test]
+    fn test_file_compatibility() {
+        let binary_formats = [
+            FileFormat::PcapNG,
+            FileFormat::PcapLegacy,
+            FileFormat::Binary,
+        ];
+        let text_formats = [FileFormat::Text];
+
+        let binary_parsers = [ParserNames::Dlt, ParserNames::SomeIP, ParserNames::Plugins];
+        let text_parsers = [ParserNames::Text, ParserNames::Plugins];
+
+        // Test Binary Formats
+        for format in binary_formats {
+            for parser in binary_parsers {
+                assert!(
+                    parser.is_compatible_file(format),
+                    "Parser {parser} should be compatible with {format:?}"
+                );
+            }
+            // Text parser should NOT be compatible with binary
+            assert!(!ParserNames::Text.is_compatible_file(format));
+        }
+
+        // Test Text Formats
+        for format in text_formats {
+            for parser in text_parsers {
+                assert!(
+                    parser.is_compatible_file(format),
+                    "Parser {parser} should be compatible with {format:?}"
+                );
+            }
+            // Binary parsers (except Plugins) should NOT be compatible with text
+            assert!(!ParserNames::Dlt.is_compatible_file(format));
+            assert!(!ParserNames::SomeIP.is_compatible_file(format));
+        }
+    }
+
+    #[test]
+    fn test_stream_compatibility() {
+        // Text: Compatible with Process, Serial. NOT Tcp, Udp
+        assert!(ParserNames::Text.is_compatible_stream(StreamNames::Process));
+        assert!(ParserNames::Text.is_compatible_stream(StreamNames::Serial));
+        assert!(!ParserNames::Text.is_compatible_stream(StreamNames::Tcp));
+        assert!(!ParserNames::Text.is_compatible_stream(StreamNames::Udp));
+
+        // Dlt/SomeIP: Compatible with Tcp, Udp, Serial. NOT Process
+        for parser in [ParserNames::Dlt, ParserNames::SomeIP] {
+            assert!(parser.is_compatible_stream(StreamNames::Tcp));
+            assert!(parser.is_compatible_stream(StreamNames::Udp));
+            assert!(parser.is_compatible_stream(StreamNames::Serial));
+            assert!(!parser.is_compatible_stream(StreamNames::Process));
+        }
+
+        // Plugins: Compatible with everything
+        for stream in [
+            StreamNames::Process,
+            StreamNames::Serial,
+            StreamNames::Tcp,
+            StreamNames::Udp,
+        ] {
+            assert!(ParserNames::Plugins.is_compatible_stream(stream));
+        }
+    }
+}

application/apps/indexer/gui/application/src/host/common/sources.rs

@@ -30,7 +30,7 @@ impl StreamNames {
     }
 
     pub fn is_compatible(self, parser: ParserNames) -> bool {
-        parser.is_compatible(self)
+        parser.is_compatible_stream(self)
     }
 }
 

application/apps/indexer/gui/application/src/host/common/ui_utls.rs

@@ -0,0 +1,16 @@
+use egui::{Frame, Margin, Ui};
+
+/// Frame used to group controls in side views.
+pub fn side_panel_group_frame(ui: &mut Ui) -> Frame {
+    Frame::group(ui.style())
+        .fill(ui.style().visuals.faint_bg_color)
+        .inner_margin(Margin::symmetric(10, 8))
+        .outer_margin(Margin::symmetric(0, 4))
+}
+
+pub fn main_panel_group_frame(ui: &mut Ui) -> Frame {
+    Frame::group(ui.style())
+        .fill(ui.style().visuals.faint_bg_color)
+        .inner_margin(Margin::symmetric(12, 12))
+        .outer_margin(Margin::symmetric(0, 4))
+}

application/apps/indexer/gui/application/src/host/message.rs

@@ -1,6 +1,9 @@
 use uuid::Uuid;
 
-use crate::{host::ui::session_setup::state::SessionSetupState, session::InitSessionParams};
+use crate::{
+    host::ui::{multi_setup::state::MultiFileState, session_setup::state::SessionSetupState},
+    session::InitSessionParams,
+};
 
 /// Messages sent from the host service to the UI.
 #[derive(Debug)]
@@ -9,6 +12,8 @@ pub enum HostMessage {
     SessionSetupOpened(SessionSetupState),
     /// Close session setup with the provided id.
     SessionSetupClosed { id: Uuid },
+    /// Close multiple files setup with the provided id.
+    MultiSetupClose { id: Uuid },
 
     /// A new session has been successfully created.
     SessionCreated {
@@ -17,7 +22,8 @@ pub enum HostMessage {
         /// instead of creating a new tab for the session.
         session_setup_id: Option<Uuid>,
     },
-
+    /// Open Session Setup for concatenating files.
+    MultiFilesSetup(MultiFileState),
     /// Host service has finished shutting down; the UI should now exit.
     Shutdown,
 }