Merge pull request #38 from matheus-git/develop

Visual feedback, mask/unmask and wait until start/stop/restart completes

Author: matheus-git

src/domain/service_repository.rs

@@ -13,6 +13,8 @@ pub trait ServiceRepository {
     fn restart_service(&self, name: &str) -> Result<Service, Box<dyn Error>>;
     fn enable_service(&self, name: &str) -> Result<Service, Box<dyn Error>>;
     fn disable_service(&self, name: &str) -> Result<Service, Box<dyn Error>>;
+    fn mask_service(&self, name: &str) -> Result<Service, Box<dyn Error>>;
+    fn unmask_service(&self, name: &str) -> Result<Service, Box<dyn Error>>;
     fn reload_daemon(&self) -> Result<(), Box<dyn std::error::Error>>;
     fn change_connection(&mut self, connection_type: ConnectionType) -> Result<(), zbus::Error>;
     fn systemctl_cat(&self, name: &str) -> Result<String, Box<dyn Error>>;

src/infrastructure/systemd_service_adapter.rs

@@ -191,21 +191,36 @@ impl ServiceRepository for SystemdServiceAdapter {
         let proxy = self.manager_proxy()?;
         let _job: OwnedObjectPath = proxy.call("StartUnit", &(name, "replace"))?;
         thread::sleep(Duration::from_millis(SLEEP_DURATION));
-        self.get_unit(name)
+        let mut service = self.get_unit(name)?;
+        while service.state().active().ends_with("ing") {
+            service = self.get_unit(name)?;
+            thread::sleep(Duration::from_millis(100));
+        }
+        Ok(service)
     }
 
     fn stop_service(&self, name: &str) -> Result<Service, Box<dyn std::error::Error>> {
         let proxy = self.manager_proxy()?;
         let _job: OwnedObjectPath = proxy.call("StopUnit", &(name.to_string(), "replace"))?;
         thread::sleep(Duration::from_millis(SLEEP_DURATION));
-        self.get_unit(name)
+        let mut service = self.get_unit(name)?;
+        while service.state().active().ends_with("ing") {
+            service = self.get_unit(name)?;
+            thread::sleep(Duration::from_millis(100));
+        }
+        Ok(service)
     }
 
     fn restart_service(&self, name: &str) -> Result<Service, Box<dyn std::error::Error>> {
         let proxy = self.manager_proxy()?;
         let _job: OwnedObjectPath = proxy.call("RestartUnit", &(name, "replace"))?;
         thread::sleep(Duration::from_millis(SLEEP_DURATION));
-        self.get_unit(name)
+        let mut service = self.get_unit(name)?;
+        while service.state().active().ends_with("ing") {
+            service = self.get_unit(name)?;
+            thread::sleep(Duration::from_millis(100));
+        }
+        Ok(service)
     }
 
     fn enable_service(&self, name: &str) -> Result<Service, Box<dyn std::error::Error>> {
@@ -224,6 +239,22 @@ impl ServiceRepository for SystemdServiceAdapter {
         self.get_unit(name)
     }
 
+    fn mask_service(&self, name: &str) -> Result<Service, Box<dyn std::error::Error>> {
+        let proxy = self.manager_proxy()?;
+        let _output: Vec<(String, String, String)> =
+        proxy.call("MaskUnitFiles", &(vec![name], false, true))?;
+        thread::sleep(Duration::from_millis(SLEEP_DURATION));
+        self.get_unit(name)
+    }
+
+    fn unmask_service(&self, name: &str) -> Result<Service, Box<dyn std::error::Error>> {
+        let proxy = self.manager_proxy()?;
+        let _output: Vec<(String, String, String)> =
+        proxy.call("UnmaskUnitFiles", &(vec![name], false))?;
+        thread::sleep(Duration::from_millis(SLEEP_DURATION));
+        self.get_unit(name)
+    }
+
     fn reload_daemon(&self) -> Result<(), Box<dyn std::error::Error>> {
         let proxy = self.manager_proxy()?;
         proxy.call::<&str, (), ()>("Reload", &())?;

src/terminal/app.rs

@@ -24,7 +24,7 @@ use crate::usecases::services_manager::ServicesManager;
 
 use super::components::details::ServiceDetails;
 use super::components::filter::{Filter, InputMode};
-use super::components::list::TableServices;
+use super::components::list::{TableServices, ServiceAction};
 use super::components::log::ServiceLog;
 
 #[derive(PartialEq)]
@@ -46,7 +46,8 @@ pub enum Actions {
     UpdateDetails,
     Filter(String),
     UpdateIgnoreListKeys(bool),
-    EditCurrentService
+    EditCurrentService,
+    ServiceAction(ServiceAction)
 }
 
 pub enum AppEvent {
@@ -174,6 +175,9 @@ fn spawn_key_event_listener(&self) {
                         details.on_key_event(key);
                     }
                 },
+                AppEvent::Action(Actions::ServiceAction(action)) => {
+                    table_service.act_on_selected_service(action);
+                }
                 AppEvent::Action(Actions::UpdateIgnoreListKeys(bool)) => {
                     table_service.set_ignore_key_events(bool);
                 }

src/terminal/components/list.rs

@@ -58,7 +58,8 @@ pub enum ServiceAction {
     Enable,
     Disable,
     RefreshAll,
-    ToggleFilter
+    ToggleFilter,
+    ToggleMask
 }
 
 pub struct TableServices {
@@ -219,6 +220,54 @@ impl TableServices {
             return;
         }
 
+        self.set_ignore_key_events(true);
+
+        match key.code {
+            KeyCode::Char('r') => {
+                self.sender.send(AppEvent::Action(Actions::ServiceAction(ServiceAction::Restart))).unwrap();
+                return;
+            }
+            KeyCode::Char('s') => {
+                self.sender.send(AppEvent::Action(Actions::ServiceAction(ServiceAction::Start))).unwrap();
+                return;
+            }
+            KeyCode::Char('x') => {
+                self.sender.send(AppEvent::Action(Actions::ServiceAction(ServiceAction::Stop))).unwrap();
+                return;
+            }
+            KeyCode::Char('e') => {
+                self.sender.send(AppEvent::Action(Actions::ServiceAction(ServiceAction::Enable))).unwrap();
+                return;
+            }
+            KeyCode::Char('d') => {
+                self.sender.send(AppEvent::Action(Actions::ServiceAction(ServiceAction::Disable))).unwrap();
+                return;
+            }
+            KeyCode::Char('u') => {
+                self.sender.send(AppEvent::Action(Actions::ServiceAction(ServiceAction::RefreshAll))).unwrap();
+                return;
+            }
+            KeyCode::Char('v') => {
+                self.sender.send(AppEvent::Action(Actions::GoLog)).unwrap();
+                return;
+            }
+            KeyCode::Char('f') => {
+                self.sender.send(AppEvent::Action(Actions::ServiceAction(ServiceAction::ToggleFilter))).unwrap();
+                return;
+            }
+            KeyCode::Char('c') => {
+                self.sender.send(AppEvent::Action(Actions::GoDetails)).unwrap();
+                return;
+            }
+            KeyCode::Char('m') => {
+                self.sender.send(AppEvent::Action(Actions::ServiceAction(ServiceAction::ToggleMask))).unwrap();
+                return;
+            }
+            _ => {}
+        }
+
+        self.set_ignore_key_events(false);
+
         let up_keys = [KeyCode::Up, KeyCode::Char('k')];
         let down_keys = [KeyCode::Down, KeyCode::Char('j')];
 
@@ -227,17 +276,6 @@ impl TableServices {
             code if up_keys.contains(&code) => self.select_previous(),
             KeyCode::PageDown => self.select_page_down(),
             KeyCode::PageUp => self.select_page_up(),
-            KeyCode::Char('r') => self.act_on_selected_service(ServiceAction::Restart),
-            KeyCode::Char('s') => self.act_on_selected_service(ServiceAction::Start),
-            KeyCode::Char('e') => self.act_on_selected_service(ServiceAction::Enable),
-            KeyCode::Char('d') => self.act_on_selected_service(ServiceAction::Disable),
-            KeyCode::Char('u') => self.act_on_selected_service(ServiceAction::RefreshAll),
-            KeyCode::Char('x') => self.act_on_selected_service(ServiceAction::Stop),
-            KeyCode::Char('v') => self.sender.send(AppEvent::Action(Actions::GoLog)).unwrap(),
-            KeyCode::Char('f') => self.act_on_selected_service(ServiceAction::ToggleFilter),
-            KeyCode::Char('c') => {
-                self.sender.send(AppEvent::Action(Actions::GoDetails)).unwrap();
-            }
             _ => {}
         }
     }
@@ -298,11 +336,20 @@ impl TableServices {
         }
     }
 
-    fn act_on_selected_service(&mut self, action: ServiceAction) {
+    pub fn act_on_selected_service(&mut self, action: ServiceAction) {
         if let Some(service) = self.get_selected_service() {
             let binding_usecase = self.usecase.clone();
             let usecase = binding_usecase.borrow();
             match action {
+                ServiceAction::ToggleMask => {
+                    match service.state().file() {
+                        "masked" => self.handle_service_result(usecase.unmask_service(service)),
+                        "masked-runtime" => self.handle_service_result(usecase.unmask_service(service)),
+                        _ => self.handle_service_result(usecase.mask_service(service)),
+                    }
+                    self.fetch_services();
+                    self.fetch_and_refresh(self.old_filter_text.clone());
+                },
                 ServiceAction::Start => self.handle_service_result(usecase.start_service(service)),
                 ServiceAction::Stop => self.handle_service_result(usecase.stop_service(service)),
                 ServiceAction::Restart => self.handle_service_result(usecase.restart_service(service)),
@@ -319,6 +366,7 @@ impl TableServices {
                 },
             }
         }
+        self.set_ignore_key_events(false);
     }
 
     fn handle_service_result(&mut self, result: Result<Service, Box<dyn Error>>) {
@@ -348,7 +396,7 @@ impl TableServices {
             )));
 
             help_text.push(Line::from(
-                "Navigate: ↑/↓ | Switch tab: ←/→ | Toggle Filter: f | Start: s | Stop: x | Restart: r | Enable: e | Disable: d | Refresh all: u | Log: v | Unit File: c"
+                "Navigate: ↑/↓ | Switch tab: ←/→ | List all: f | Start: s | Stop: x | Restart: r | Enable: e | Disable: d | Mask/Unmask: m | Refresh list: u | Log: v | Unit File: c"
             ));
         }
 

src/usecases/services_manager.rs

@@ -39,6 +39,16 @@ impl ServicesManager {
         self.repository.reload_daemon()?;
         Ok(service)
     }
+    
+    pub fn mask_service(&self, service: &Service) -> Result<Service, Box<dyn Error>> {
+        let service = self.repository.mask_service(service.name())?;
+        Ok(service)
+    }
+
+    pub fn unmask_service(&self, service: &Service) -> Result<Service, Box<dyn Error>> {
+        let service = self.repository.unmask_service(service.name())?;
+        Ok(service)
+    }
 
     pub fn list_services(&self, filter: bool) -> Result<Vec<Service>, Box<dyn Error>> {
         let mut all = Vec::new();