Rename Watchdog to Taskchain (#90)

* refactor: rename Watchdog -> Taskchain

* remove: Taskchain subscribers/event

Author: Kitt3120

src/service.rs

@@ -1,13 +1,13 @@
 pub mod discord;
 pub mod service; // Will be fixed when lum gets seperated into multiple workspaces
 pub mod service_manager;
+pub mod taskchain;
 pub mod types;
-pub mod watchdog;
 
 pub use service::{Service, ServiceInfo};
 pub use service_manager::{ServiceManager, ServiceManagerBuilder};
+pub use taskchain::Taskchain;
 pub use types::{
     BoxedError, LifetimedPinnedBoxedFuture, LifetimedPinnedBoxedFutureResult, OverallStatus,
     PinnedBoxedFuture, PinnedBoxedFutureResult, Priority, ShutdownError, StartupError, Status,
 };
-pub use watchdog::Watchdog;

src/service/service_manager.rs

@@ -2,10 +2,11 @@ use super::{
     service::Service,
     types::{OverallStatus, Priority, ShutdownError, StartupError, Status},
 };
-use crate::{event::EventRepeater, service::Watchdog};
+use crate::{event::EventRepeater, service::Taskchain};
 use log::{error, info, warn};
 use std::{
     collections::HashMap,
+    error::Error,
     fmt::{self, Display},
     mem,
     sync::{Arc, OnceLock, Weak},
@@ -81,7 +82,7 @@ impl ServiceManagerBuilder {
 
 pub struct ServiceManager {
     weak: OnceLock<Weak<Self>>,
-    background_tasks: Mutex<HashMap<String, JoinHandle<()>>>,
+    background_tasks: Mutex<HashMap<String, JoinHandle<Result<(), Box<dyn Error + Send + Sync>>>>>,
 
     pub services: Vec<Arc<Mutex<dyn Service>>>,
     pub on_status_change: Arc<EventRepeater<Status>>,
@@ -450,13 +451,9 @@ impl ServiceManager {
 
         let task = service_lock.task();
         if let Some(task) = task {
-            let mut watchdog = Watchdog::new(task);
+            let mut taskchain = Taskchain::new(task);
 
-            watchdog.append(|result| async move {
-                /*
-                    We technically only need a read lock here, but we want to immediately stop
-                    other services from accessing the service, so we acquire a write lock instead.
-                */
+            taskchain.append(|result| async move {
                 let service = service.lock().await;
 
                 match result {
@@ -492,7 +489,7 @@ impl ServiceManager {
                 Ok(())
             });
 
-            let join_handle = spawn(watchdog.run());
+            let join_handle = spawn(taskchain.run());
 
             self.background_tasks
                 .lock()

src/service/taskchain.rs

@@ -0,0 +1,36 @@
+use core::mem;
+use std::future::Future;
+
+use super::LifetimedPinnedBoxedFuture;
+
+pub struct Taskchain<'a, T: Send + Sync + 'static> {
+    task: LifetimedPinnedBoxedFuture<'a, T>,
+}
+
+impl<'a, T: Send + Sync + 'static> Taskchain<'a, T> {
+    pub fn new(task: LifetimedPinnedBoxedFuture<'a, T>) -> Self {
+        Self { task }
+    }
+
+    pub fn append<FN, FUT>(&mut self, task: FN)
+    where
+        FN: FnOnce(T) -> FUT + Send + Sync + 'a,
+        FUT: Future<Output = T> + Send + Sync + 'a,
+    {
+        let previous_task = mem::replace(
+            &mut self.task,
+            Box::pin(async { unreachable!("Undefined Taskchain task") }),
+        );
+
+        let task = async move {
+            let result = previous_task.await;
+            task(result).await
+        };
+
+        self.task = Box::pin(task);
+    }
+
+    pub async fn run(self) -> T {
+        self.task.await
+    }
+}