mark units that failed at startup as StoppedFinal

Author: KillingSpark

src/control/control.rs

@@ -290,14 +290,15 @@ pub fn execute_command(
                     for unit in units {
                         let unit_locked = unit.lock().unwrap();
                         let status = {
-                            *run_info
+                            run_info
                                 .status_table
                                 .read()
                                 .unwrap()
                                 .get(&unit_locked.id)
                                 .unwrap()
                                 .lock()
                                 .unwrap()
+                                .clone()
                         };
                         if name.ends_with(".service") {
                             result_vec
@@ -327,14 +328,15 @@ pub fn execute_command(
                         .map(|(_id, unit)| {
                             let unit_locked = &unit.lock().unwrap();
                             let status = {
-                                *run_info
+                                run_info
                                     .status_table
                                     .read()
                                     .unwrap()
                                     .get(&unit_locked.id)
                                     .unwrap()
                                     .lock()
                                     .unwrap()
+                                    .clone()
                             };
                             match unit_locked.specialized {
                                 UnitSpecialized::Socket(_) => format_socket(&unit_locked, status),

src/socket_activation.rs

@@ -50,7 +50,7 @@ pub fn start_socketactivation_thread(
                             {
                                 let srvc_status = {
                                     let status_locked = status.lock().unwrap();
-                                    *status_locked
+                                    status_locked.clone()
                                 };
 
                                 if srvc_status != crate::units::UnitStatus::StartedWaitingForSocket {

src/units/activate.rs

@@ -113,8 +113,8 @@ fn activate_units_recursive(
                     tpool_copy.execute(next_services_job);
                 }
                 Ok(StartResult::WaitForDependencies) => {
-                    // Thats ok. The unit is waiting for more dependencies
-                    // TODO make this more explicit
+                    // Thats ok. The unit is waiting for more dependencies and will be
+                    // activated again when another dependency has finished starting
                 }
                 Err(e) => {
                     error!("Error while activating unit {}", e);
@@ -233,6 +233,13 @@ pub fn activate_unit(
             let mut status_locked = status.lock().unwrap();
             *status_locked = new_status;
             StartResult::Started(next_services_ids)
+        }).map_err(|e| {
+            // Update the status while we still lock the unit
+            let status_table_locked = run_info.status_table.read().unwrap();
+            let status = status_table_locked.get(&unit_locked.id).unwrap();
+            let mut status_locked = status.lock().unwrap();
+            *status_locked = UnitStatus::StoppedFinal(format!("{}", e));
+            e
         })
     // drop all the locks "at once". Ordering of dropping should be irrelevant?
 }

src/units/deactivate.rs

@@ -41,7 +41,7 @@ pub fn deactivate_unit(
             }
             UnitStatus::NeverStarted
             | UnitStatus::Stopped
-            | UnitStatus::StoppedFinal
+            | UnitStatus::StoppedFinal(_)
             | UnitStatus::Stopping => {
                 return Ok(());
             }
@@ -53,7 +53,7 @@ pub fn deactivate_unit(
         let status = status_table_locked.get(&id_to_kill).unwrap();
         let mut status_locked = status.lock().unwrap();
         if killfinal {
-            *status_locked = UnitStatus::StoppedFinal;
+            *status_locked = UnitStatus::StoppedFinal("Deactivated cleanly".into());
         } else {
             *status_locked = UnitStatus::Stopped;
         }

src/units/units.rs

@@ -91,15 +91,15 @@ pub enum PidEntry {
     HelperExited(crate::signal_handler::ChildTermination),
 }
 
-#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+#[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub enum UnitStatus {
     NeverStarted,
     Starting,
     Started,
     StartedWaitingForSocket,
     Stopping,
     Stopped,
-    StoppedFinal,
+    StoppedFinal(String),
 }
 
 #[derive(Debug)]