Merge viz tool updates (#4)

* Merge viz tool updates

* Fix ts_storage path

* CHange rust_ts_storage dependancy to s_storage

---------

Co-authored-by: Moritz Flüchter <moritz.fluechter@uni-tuebingen.de>

Author: MoritzFlu

tcbee/Cargo.lock

@@ -1,5 +1,5 @@
 [package]
-name = "viz-tool"
+name = "tcp_visualization_application"
 version = "0.1.0"
 authors = ["ScatteredDrifter"]
 edition = "2021"

viz-tool/Cargo.toml

@@ -38,12 +38,15 @@ use iced_aw::Tabs;
 use ts_storage::{DataValue, TSDBInterface};
 use std::cell::RefCell;
 use std::sync::{Arc, RwLock};
+use std::thread::sleep;
+use std::time::{Duration, Instant};
 
 // ---- //
 // --- //
 
 // fn main() -> iced::Result {
 fn main() -> iced::Result {
+    println!("Hi, this application was written by Evelyn :>\n this message is a secret");
     iced::application("TCPFLOW", StateContainer::update, StateContainer::view)
         .theme(StateContainer::theme)
         .run()
@@ -104,16 +107,34 @@ impl Default for StateContainer {
             screen_multi_flow_plotting: ScreenMultiFlowPlotting::new(settings.clone()),
             screen_modify_database: ScreenModifyDatabase::new(settings.clone()),
             application_settings: settings,
-            theme: Theme::CatppuccinFrappe,
+            // theme: Theme::CatppuccinFrappe,
+            theme: Theme::GruvboxLight,
         }
     }
 }
 
 // Implementations for ICED
 impl StateContainer {
     fn update(&mut self, message: Message) {
+        print!("{esc}c", esc = 27 as char);
         match message {
-            Message::TabSelected(new_screen) => self.screen = new_screen,
+            Message::TabSelected(new_screen) => {
+                match self.screen {
+                    ActiveScreen::DatabaseModification => {
+                        self.screen_modify_database.reset();
+                    }
+                    ActiveScreen::SingleGraphPlot => {
+                        self.screen_plotting.reset();
+                    }
+                    ActiveScreen::MultipleGraphPlot => {
+                        self.screen_multi_flow_plotting.reset();
+                    }
+                    _ => {
+
+                    }
+                }
+                self.screen = new_screen
+            }
             Message::TabClosed(_) => {}
             Message::ScreenSettings(message) => self.screen_settings.update(message),
             Message::ScreenHome(message) => self.screen_home.update(message),

viz-tool/src/main.rs

@@ -18,7 +18,7 @@ use iced::widget::canvas::Cache;
 use plotters::style::RGBAColor;
 use ts_storage::{database_factory, sqlite::SQLiteTSDB, DBBackend, DataValue, Flow};
 use ts_storage::{DataPoint, TimeSeries};
-use std::{cell::RefCell, slice::Iter, sync::RwLock};
+use std::{cell::RefCell, f64::{MAX, MIN}, path::PathBuf, slice::Iter, sync::RwLock};
 
 // testing to adapt to issue of not refrencing well enough?
 use std::sync::Arc;
@@ -53,10 +53,7 @@ impl ToString for DataSource {
 pub struct IntermediateBackend {
     pub source_type: DataSource,
     pub database_interface: Option<Arc<Box<dyn TSDBInterface>>>,
-    // for access management
-    // selected_flow: Option<i64>,
-    // FIXME should be Id of attribute instead
-    // pub selected_series_attributes: Option<Vec<i64>>,
+    pub database_path: Option<PathBuf>,
 }
 
 impl IntermediateBackend {
@@ -66,16 +63,17 @@ impl IntermediateBackend {
                 // if it was selected we know that its available!
                 let db_connection = self.database_interface.clone().unwrap();
                 let flow = db_connection.get_flow_by_id(*value).unwrap().unwrap();
-                let bounds = db_connection
-                    .get_flow_bounds(&flow)
-                    .expect("no bounds could be received for flow");
-
-                Some(ZoomBound {
-                    lower: bounds.xmin,
-                    upper: bounds.xmax,
-                })
-
-                // Some(bounds.unwrap())
+                let maybe_bounds = db_connection
+                    .get_flow_bounds(&flow);
+                match maybe_bounds{
+                    Ok(boundaries) => {
+                        Some(ZoomBound {
+                            lower: boundaries.xmin,
+                            upper: boundaries.xmax,
+                        })
+                    }
+                    _ => None 
+                }
             }
             _ => None,
         }
@@ -86,17 +84,17 @@ impl IntermediateBackend {
         collection_of_series: Option<Vec<i64>>,
     ) -> Option<ZoomBound> {
         if let Some(series) = self.receive_active_timeseries(collection_of_series) {
-            let db_conection = self.database_interface.clone().unwrap();
+            let db_connection = self.database_interface.clone().unwrap();
 
-            let mut lowest_y: f64 = DEFAULT_Y_MIN;
-            let mut highest_y: f64 = DEFAULT_Y_MAX;
+            let mut lowest_y: f64 = MAX;
+            let mut highest_y: f64 = MIN;
             for series_id in series {
-                let boundaries = db_conection
+                let boundaries = db_connection
                     .get_time_series_bounds(&series_id)
                     .expect("could not receive boundaries");
-                if let Some(_) = boundaries.ymin {
-                    let lower = boundaries.ymin.unwrap();
-                    let upper = boundaries.ymax.unwrap();
+                if let (Some(y_min),Some(y_max)) = (&boundaries.ymin , &boundaries.ymax) {
+                    let lower = y_min;
+                    let upper = y_max;
                     // guaranteed to be DataValue
                     match series_id.ts_type {
                         DataValue::Float(_) => {
@@ -113,6 +111,15 @@ impl IntermediateBackend {
                     }
                 }
             }
+
+            // println!("Debug: y boundaries are:\n low:{:?}\n high: {:?}",lowest_y,highest_y);
+            if lowest_y == highest_y {
+                // ASSUME: found constant, hence creating new boundaries
+                let old_constant = lowest_y;
+                lowest_y = old_constant - 10.0;
+                highest_y = old_constant + 10.0;
+            }
+            
             return Some(ZoomBound {
                 lower: lowest_y,
                 upper: highest_y,
@@ -256,8 +263,7 @@ impl Clone for IntermediateBackend {
         IntermediateBackend {
             source_type: self.source_type.clone(),
             database_interface: self.database_interface.clone(),
-            // selected_flow: self.selected_flow.clone(),
-            // selected_series_attributes: self.selected_series_attributes.clone(),
+            database_path: self.database_path.clone(),
         }
     }
 }
@@ -267,20 +273,20 @@ impl IntermediateBackend {
         match source {
             DataSource::Sqllite => {
                 let db_interface: Arc<Box<dyn TSDBInterface>> = Arc::new(
-                    database_factory::<SQLiteTSDB>(DBBackend::SQLite(path_db))
+                    database_factory::<SQLiteTSDB>(DBBackend::SQLite(path_db.clone()))
                         .expect("could not parse database"),
                 );
                 println!("initialized database of time {:?}", source);
                 IntermediateBackend {
                     source_type: source.clone(),
                     database_interface: Some(db_interface),
-                    // selected_flow: None,
-                    // selected_series_attributes: None,
+                    database_path: Some(PathBuf::from(path_db))
                 }
             }
             _ => IntermediateBackend {
                 source_type: source.clone(),
                 database_interface: None,
+                database_path: None,
                 // selected_flow: None,
                 // selected_series_attributes: None,
             },

viz-tool/src/modules/backend/intermediate_backend.rs

@@ -3,7 +3,7 @@
 // - filesystem interactionA
 
 use crate::DataSource;
-use std::path::PathBuf;
+use std::{fs::{self, Metadata}, path::PathBuf, time::{SystemTime, UNIX_EPOCH}};
 
 pub fn receive_source_from_path(path: &PathBuf) -> Option<DataSource> {
     let extension = path.extension().unwrap().to_str().unwrap();
@@ -13,3 +13,21 @@ pub fn receive_source_from_path(path: &PathBuf) -> Option<DataSource> {
         _ => None,
     }
 }
+
+pub fn receive_file_metadata(path: &PathBuf) -> String { 
+    let metadata_object = fs::metadata(path).unwrap();
+    let file_size = metadata_object.len();
+    let file_size_as_mb = (file_size / 1_048_576) as f64;
+    let maybe_cr_time = metadata_object.created();
+    let cr_time = match maybe_cr_time{
+        Ok(cr_time) => {
+            format!("{:?}",cr_time.duration_since(UNIX_EPOCH))
+        }
+        Err(_) => {
+            "could not obtain creation time".to_string()
+        }
+    };
+    let bundled_information = String::from(format!("size:{:?}mb\ncreated:{:?}",file_size_as_mb,cr_time));
+    bundled_information
+
+}

viz-tool/src/modules/backend/lib_system_io.rs

@@ -459,4 +459,9 @@ impl Screen for ScreenModifyDatabase {
 
         combined_content.map(Message::ScreenModifyDatabase)
     }
+
+    fn reset(&mut self) {
+        self.clear_flow_data();
+        self.selected_flow = TcpFlowWrapper::default();
+    }
 }

viz-tool/src/modules/ui/lib_screens/screen_database_modification.rs

@@ -216,4 +216,7 @@ impl Screen for ScreenHome {
         // let window_content = generate_one_fourth_layout::<MessageHome>(headline_content, sidebar, explanation_field)
         window_content.map(Message::ScreenHome)
     }
+    fn reset(&mut self) {
+        
+    }
 }

viz-tool/src/modules/ui/lib_screens/screen_home.rs

@@ -52,6 +52,7 @@ pub enum MessageMultiFlowPlotting {
     GraphGenerationRequested,
     SplitChartRequested(bool),
     DrawLineSeriesRequested(bool),
+    UnselectAllSeries,
     // zooming
     SliderZoomLX(f64),
     SliderZoomRX(f64),
@@ -275,6 +276,10 @@ impl ScreenMultiFlowPlotting {
                     _ => {}
                 }
             }
+            MessageMultiFlowPlotting::UnselectAllSeries => { 
+                    self.first_tcp_flow.selected_series = None;
+                    self.second_tcp_flow.selected_series = None;
+            }
             _ => (),
 
         }
@@ -328,6 +333,7 @@ impl ScreenMultiFlowPlotting {
             MessageMultiFlowPlotting::FlowOneSelected,
             MessageMultiFlowPlotting::FlowOneFeatureSelected,
             MessageMultiFlowPlotting::FlowOneFeatureDeselected,
+            MessageMultiFlowPlotting::UnselectAllSeries,
         )
         .width(Length::FillPortion(FLOW1_SELECTION_PORTION));
         let selector_flow_2 = display_combined_flow_selection(
@@ -337,6 +343,7 @@ impl ScreenMultiFlowPlotting {
             MessageMultiFlowPlotting::FlowTwoSelected,
             MessageMultiFlowPlotting::FlowTwoFeatureSelected,
             MessageMultiFlowPlotting::FlowTwoFeatureDeselected,
+            MessageMultiFlowPlotting::UnselectAllSeries,
         )
         .width(Length::FillPortion(FLOW2_SELECTION_PORTION));
         let content = Row::new()
@@ -388,7 +395,7 @@ impl ScreenMultiFlowPlotting {
     }
 
     fn generate_chart_view(&self) -> Element<'_,MessageMultiFlowPlotting> { 
-        let generate_top_info:bool = !self.render_chart && self.first_tcp_flow.selected_series.is_some() && self.second_tcp_flow.selected_series.is_some();
+        let generate_top_info:bool = self.render_chart && self.first_tcp_flow.selected_series.is_some() && self.second_tcp_flow.selected_series.is_some();
         let maybe_legends = generate_legends_for_charts(generate_top_info, &self.plot_data);
         let mouse_position = display_current_mouse_position(self.current_position);
         let merged_top_info = Row::new()
@@ -475,4 +482,10 @@ impl Screen for ScreenMultiFlowPlotting {
 
         padded_content.map(Message::ScreenMultipleFlowPlot)
     }
+
+    fn reset(&mut self) {
+        self.first_tcp_flow = TcpFlowWrapper::default();
+        self.second_tcp_flow = TcpFlowWrapper::default();
+        self.plot_data = None;
+    }
 }

viz-tool/src/modules/ui/lib_screens/screen_multiple_flow_plotting.rs

@@ -273,4 +273,8 @@ impl Screen for ScreenSettings {
 
         window_content.map(Message::ScreenSettings)
     }
+
+    fn reset(&mut self) {
+        
+    }
 }

viz-tool/src/modules/ui/lib_screens/screen_settings.rs

@@ -82,6 +82,7 @@ pub enum MessagePlotting {
     // ZoomRangeChanged(f64),
     GraphGenerationRequested,
     ZoomResetRequested,
+    UnselectAllSeries,
     CheckBoxMultiplePlots(bool),
     CheckBoxDrawLineSeries(bool),
     MouseEvent(iced::mouse::Event, iced::Point),
@@ -186,6 +187,7 @@ impl ScreenSingleFlowPlotting {
                 self.render_chart = false;
 
                 self.tcp_flow.flow_id = Some(reference_id);
+                self.tcp_flow.selected_series = None;
                 let new_zoom = retrieve_default_zoom_for_one_flow(&self.application_settings, &self.tcp_flow);
                 self.zoom_bounds = Some(new_zoom);
             }
@@ -219,6 +221,9 @@ impl ScreenSingleFlowPlotting {
                     self.render_chart = false
                 }
             }
+            MessagePlotting::UnselectAllSeries => {
+                self.tcp_flow.selected_series = None;
+            }
 
             // if called we generate the chart - otherwise not.
             // Could be done with a boolean  but this might be unfortunate
@@ -386,7 +391,7 @@ impl ScreenSingleFlowPlotting {
     }
 
     pub fn generate_chart_view(&self) -> Element<'_, MessagePlotting> {
-        let generate_legends: bool = !self.render_chart
+        let generate_legends: bool = self.render_chart
             && self.tcp_flow.flow_id.is_some()
             && self.tcp_flow.selected_series.is_some();
         let graph_top_info: Row<'_, MessagePlotting> = Row::new()
@@ -421,6 +426,7 @@ impl ScreenSingleFlowPlotting {
             MessagePlotting::FlowSelected,
             MessagePlotting::FlowFeatureSelected,
             MessagePlotting::FlowFeatureDeSelected,
+            MessagePlotting::UnselectAllSeries,
         );
 
         let combined_buttons = display_combined_flow_buttons(
@@ -522,6 +528,11 @@ impl Screen for ScreenSingleFlowPlotting {
 
         content.map(Message::ScreenSingleFlowPlot)
     }
+
+    fn reset(&mut self) {
+        self.tcp_flow = TcpFlowWrapper::default();
+        self.processed_plot_data = None;
+    }
 }
 
 impl ScreenSingleFlowPlotting {