Native: Move handling search operation to UI

* Move operation tracking for search to UI state to handle all
  operations in one side.
* Improve UI handling for search state since more infos are available.
* Best possible fixes to searches going out of sync in UI without
  changing search logic in rust core.

Author: AmmarAbouZor

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

@@ -4,6 +4,7 @@ use std::sync::mpsc::Sender;
 
 use processor::{grabber::LineRange, search::filter::SearchFilter};
 use stypes::GrabbedElement;
+use uuid::Uuid;
 
 use crate::session::error::SessionError;
 
@@ -16,9 +17,14 @@ use crate::session::error::SessionError;
 #[derive(Debug)]
 pub enum SessionCommand {
     /// Apply the provided search filters.
-    ApplySearchFilter(Vec<SearchFilter>),
+    ApplySearchFilter {
+        operation_id: Uuid,
+        filters: Vec<SearchFilter>,
+    },
     /// Cancel current search and clear results.
-    DropSearch,
+    /// If search operation is still processing then a search id will be provided
+    /// to abort this operation.
+    DropSearch { operation_id: Option<Uuid> },
     /// Request the nearest index in the search view for a given main-log index.
     GetNearestPosition(u64),
 

application/apps/indexer/gui/application/src/session/service/mod.rs

@@ -19,16 +19,12 @@ use crate::{
         ui::{SessionInfo, chart::ChartBar},
     },
 };
-use operation_track::OperationTracker;
-
-mod operation_track;
 
 #[derive(Debug)]
 pub struct SessionService {
     cmd_rx: mpsc::Receiver<SessionCommand>,
     senders: ServiceSenders,
     session: Session,
-    ops_tracker: OperationTracker,
     callback_rx: mpsc::UnboundedReceiver<CallbackEvent>,
 }
 
@@ -58,7 +54,6 @@ impl SessionService {
             cmd_rx,
             senders,
             session,
-            ops_tracker: OperationTracker::default(),
             callback_rx,
         };
 
@@ -155,17 +150,14 @@ impl SessionService {
                     );
                 }
             }
-            SessionCommand::ApplySearchFilter(search_filters) => {
-                let op_id = Uuid::new_v4();
-                debug_assert!(
-                    self.ops_tracker.filter_op.is_none(),
-                    "filter must be dropped before applying new one"
-                );
-                self.ops_tracker.filter_op = Some(op_id);
-                self.session.apply_search_filters(op_id, search_filters)?;
+            SessionCommand::ApplySearchFilter {
+                operation_id,
+                filters,
+            } => {
+                self.session.apply_search_filters(operation_id, filters)?;
             }
-            SessionCommand::DropSearch => {
-                if let Some(filter_op) = self.ops_tracker.filter_op.take() {
+            SessionCommand::DropSearch { operation_id } => {
+                if let Some(filter_op) = operation_id {
                     self.session.abort(Uuid::new_v4(), filter_op)?;
                 }
                 self.session.drop_search().await?;
@@ -254,11 +246,6 @@ impl SessionService {
             SessionCommand::CloseSession => {
                 // Session UI can be already dropped at this point, therefore
                 // we don't need to send errors to UI in this case.
-                for op_id in self.ops_tracker.get_all() {
-                    if let Err(err) = self.session.abort(Uuid::new_v4(), op_id) {
-                        log::error!("Abort operation failed. {err:?}");
-                    }
-                }
 
                 if let Err(err) = self.session.stop(Uuid::new_v4()).await {
                     log::error!("Stopping session failed. {err:?}");
@@ -283,21 +270,20 @@ impl SessionService {
                     .send_session_msg(SessionMessage::LogsCount(logs_count))
                     .await;
             }
-            // TODO AAZ: Search callbacks seem to have duplications. Check
-            // how they're used in master.
-            //
-            // CallbackEvent::SearchUpdated { found, stat } => {
-            // }
+            CallbackEvent::SearchUpdated { found, stat: _ } => {
+                // TODO AAZ: For now I'm updating the total count of logs.
+                // But this will be changed once we got to multiple filters.
+                self.senders
+                    .send_session_msg(SessionMessage::SearchState { found_count: found })
+                    .await;
+            }
             CallbackEvent::IndexedMapUpdated { len } => {
                 self.senders
                     .send_session_msg(SessionMessage::SearchState { found_count: len })
                     .await;
             }
             CallbackEvent::SearchMapUpdated(filter_matches) => {
                 if let Some(list) = filter_matches {
-                    // Long process ends when it deliver its initial results.
-                    self.ops_tracker.filter_op = None;
-
                     self.senders
                         .send_session_msg(SessionMessage::SearchResults(list.0))
                         .await;

application/apps/indexer/gui/application/src/session/ui/bottom_panel/chart/mod.rs

@@ -1,13 +1,13 @@
 use std::{ops::RangeInclusive, time::Duration};
 
-use egui::{Color32, Direction, Label, Layout, Ui, Vec2, Widget};
+use egui::{Color32, Direction, Label, Layout, Spinner, Ui, Vec2, Widget};
 use egui_plot::{Bar, BarChart, Legend, Plot};
 use tokio::sync::mpsc::Sender;
 
 use crate::{
     common::action_throttle::ActionThrottle,
     host::ui::UiActions,
-    session::{command::SessionCommand, ui::shared::SessionShared},
+    session::{command::SessionCommand, types::OperationPhase, ui::shared::SessionShared},
 };
 
 pub use data::{ChartBar, ChartsData};
@@ -82,10 +82,18 @@ impl ChartUI {
         actions: &mut UiActions,
         ui: &mut Ui,
     ) {
-        if shared.search.is_search_active() {
-            self.chart(shared, actions, ui);
-        } else {
-            Self::place_holder(ui);
+        match shared.search.search_operation_phase() {
+            Some(OperationPhase::Initializing) => {
+                ui.centered_and_justified(|ui| {
+                    Spinner::new().size(20.0).ui(ui);
+                });
+            }
+            Some(OperationPhase::Processing | OperationPhase::Done) => {
+                self.chart(shared, actions, ui);
+            }
+            None => {
+                Self::place_holder(ui);
+            }
         }
     }
 
@@ -177,7 +185,7 @@ impl ChartUI {
                 plot_ui.set_auto_bounds([false, true]);
             }
 
-            if shared.search.total_count == 0 {
+            if shared.search.total_count() == 0 {
                 return PlotResponse::None;
             }
 
@@ -203,7 +211,7 @@ impl ChartUI {
                         return PlotResponse::RequestForRange(bounds_x);
                     }
                 }
-                None if shared.search.total_count > 0 => {
+                None if shared.search.total_count() > 0 => {
                     // This is the first render frame after having search results.
 
                     //TODO AAZ: It would make sense to update this on logs_count changed.

application/apps/indexer/gui/application/src/session/ui/bottom_panel/search/mod.rs

@@ -8,6 +8,7 @@ use crate::{
     host::ui::UiActions,
     session::{
         command::SessionCommand,
+        types::OperationPhase,
         ui::{definitions::schema::LogSchema, shared::SessionShared},
     },
 };
@@ -40,7 +41,11 @@ impl SearchUI {
     ) {
         self.bar.render_content(shared, actions, ui);
 
-        if shared.search.is_search_active() {
+        if shared
+            .search
+            .search_operation_phase()
+            .is_some_and(|ph| ph != OperationPhase::Initializing)
+        {
             // We need to give a unique id for the direct parent of each table because
             // they will be used as identifiers for table state to avoid ID clashes between
             // tables from different tabs (different sessions).

application/apps/indexer/gui/application/src/session/ui/bottom_panel/search/search_bar.rs

@@ -5,11 +5,12 @@ use egui::{
     Ui, Widget, vec2,
 };
 use processor::search::filter::SearchFilter;
+use uuid::Uuid;
 
 use crate::{
     common::phosphor::{self, icons},
     host::ui::UiActions,
-    session::{command::SessionCommand, ui::shared::SessionShared},
+    session::{command::SessionCommand, types::OperationPhase, ui::shared::SessionShared},
 };
 
 #[derive(Debug, Clone)]
@@ -80,9 +81,13 @@ impl SearchBar {
                 self.is_word,
             );
 
-            let cmd = SessionCommand::ApplySearchFilter(vec![filter.clone()]);
+            let operation_id = Uuid::new_v4();
+            let cmd = SessionCommand::ApplySearchFilter {
+                operation_id,
+                filters: vec![filter.clone()],
+            };
             if actions.try_send_command(&self.cmd_tx, cmd) {
-                shared.search.activate();
+                shared.search.set_search_operation(operation_id);
                 self.temp_filter = Some(filter);
             }
         }
@@ -214,15 +219,20 @@ impl SearchBar {
         }
 
         ui.horizontal_centered(|ui| {
-            let percentage = shared.search.total_count as f32 / logs_count as f32 * 100.;
+            let percentage = shared.search.total_count() as f32 / logs_count as f32 * 100.;
 
             let state_txt = format!(
                 "{}/{} ({percentage:.2}%)",
-                shared.search.total_count, logs_count,
+                shared.search.total_count(),
+                logs_count,
             );
             Label::new(state_txt).selectable(false).ui(ui);
 
-            if shared.search.current_matches_map().is_none() {
+            if shared
+                .search
+                .search_operation_phase()
+                .is_some_and(|ph| ph == OperationPhase::Initializing)
+            {
                 ui.spinner();
             }
         });
@@ -231,7 +241,8 @@ impl SearchBar {
     }
 
     fn drop_search(&self, shared: &mut SessionShared, actions: &mut UiActions) {
-        actions.try_send_command(&self.cmd_tx, SessionCommand::DropSearch);
+        let operation_id = shared.search.processing_search_operation();
+        actions.try_send_command(&self.cmd_tx, SessionCommand::DropSearch { operation_id });
         shared.drop_search();
     }
 }

application/apps/indexer/gui/application/src/session/ui/bottom_panel/search/search_table.rs

@@ -71,14 +71,14 @@ impl SearchTable {
 
         let mut table = egui_table::Table::new()
             .id_salt(id_salt)
-            .num_rows(shared.search.total_count)
+            .num_rows(shared.search.total_count())
             .headers(Vec::new())
             .columns(self.columns.as_ref())
             .auto_size_mode(AutoSizeMode::Never)
             .num_sticky_cols(1);
 
         if let Some(row_nr) = self.scroll_nearest_pos.take().map(|pos| pos.index)
-            && row_nr < shared.search.total_count
+            && row_nr < shared.search.total_count()
         {
             const OFFSET: u64 = 2;
             table = table.scroll_to_rows(row_nr.saturating_sub(OFFSET)..=row_nr + OFFSET, None);
@@ -180,7 +180,7 @@ impl TableDelegate for LogsDelegate<'_> {
             // Request new data.
             self.table.last_visible_rows = Some(info.visible_rows.to_owned());
 
-            if self.shared.search.total_count == 0 {
+            if self.shared.search.total_count() == 0 {
                 return;
             }
 

application/apps/indexer/gui/application/src/session/ui/mod.rs

@@ -168,7 +168,7 @@ impl Session {
                     self.shared.logs.selected_log = selected;
                 }
                 SessionMessage::SearchState { found_count } => {
-                    self.shared.search.total_count = found_count;
+                    self.shared.search.set_total_count(found_count);
                     self.bottom_panel
                         .chart
                         .on_search_count_changes(&self.shared);
@@ -199,7 +199,20 @@ impl Session {
                     operation_id,
                     phase,
                 } => {
-                    if self.shared.observe.update(operation_id, phase).consumed() {
+                    if self
+                        .shared
+                        .observe
+                        .update_operation(operation_id, phase)
+                        .consumed()
+                    {
+                        return;
+                    }
+                    if self
+                        .shared
+                        .search
+                        .update_operation(operation_id, phase)
+                        .consumed()
+                    {
                         return;
                     }
                     // Potential components which keep track for operations can go here.

application/apps/indexer/gui/application/src/session/ui/shared/observe.rs

@@ -17,7 +17,11 @@ impl ObserveState {
         }
     }
 
-    pub fn update(&mut self, operation_id: Uuid, phase: OperationPhase) -> UpdateOperationOutcome {
+    pub fn update_operation(
+        &mut self,
+        operation_id: Uuid,
+        phase: OperationPhase,
+    ) -> UpdateOperationOutcome {
         if let Some(observe) = self.operations.iter_mut().find(|o| o.id == operation_id) {
             observe.set_phase(phase);
             UpdateOperationOutcome::Consumed