Cargo.toml

@@ -80,7 +80,6 @@ derive_more = { version = "1.0.0-beta.6", features = [
   "from",
 ] }
 derive-with = "0.5"
-anyhow = "1.0"
 thiserror = "1.0"
 pike = "0.1"
 

crates/cli/Cargo.toml

@@ -50,7 +50,6 @@ actix-rt = { workspace = true }
 # boilerplate
 derive_more = { workspace = true }
 derive-with = { workspace = true }
-anyhow = { workspace = true }
 thiserror = { workspace = true }
 
 # Webhooks

crates/cli/src/file_watcher.rs

@@ -2,7 +2,6 @@
 use actix::prelude::*;
 
 use actix::Recipient;
-use anyhow::{Context, Result};
 use notify::event::ModifyKind;
 use notify::Watcher;
 use tracing::error;
@@ -20,13 +19,15 @@ pub enum Error {
     #[error("io")]
     Io(#[from] std::io::Error),
 }
-pub async fn watch_file(path: PathBuf, recipient: Recipient<FileUpdated>) -> Result<()> {
+pub async fn watch_file(path: PathBuf, recipient: Recipient<FileUpdated>) {
     let (tx, rx) = std::sync::mpsc::channel();
 
-    let mut handler = notify::recommended_watcher(tx).context("file watcher")?;
+    #[allow(clippy::expect_used)]
+    let mut handler = notify::recommended_watcher(tx).expect("file watcher");
+    #[allow(clippy::expect_used)]
     handler
         .watch(&path, notify::RecursiveMode::NonRecursive)
-        .with_context(|| format!("Watch file: {path:?}"))?;
+        .expect("watch file");
     info!("Watching: {:?}", path);
     async move {
         loop {
@@ -54,5 +55,4 @@ pub async fn watch_file(path: PathBuf, recipient: Recipient<FileUpdated>) -> Res
         }
     }
     .await;
-    Ok(())
 }

crates/cli/src/init.rs

@@ -1,18 +1,29 @@
 //
-use anyhow::{Context, Result};
 use kxio::fs::FileSystem;
 
-pub fn run(fs: FileSystem) -> Result<()> {
+pub fn run(fs: FileSystem) {
-    let pathbuf = fs.base().join(".git-next.toml");
+    let file_name = ".git-next.toml";
-    if fs
+    let pathbuf = fs.base().join(file_name);
-        .path_exists(&pathbuf)
+    match fs.path_exists(&pathbuf) {
-        .with_context(|| format!("Checking for existing file: {pathbuf:?}"))?
+        Ok(exists) => {
-    {
+            if exists {
-        eprintln!("The configuration file already exists at {pathbuf:?} - not overwritting it.",);
+                eprintln!(
-    } else {
+                    "The configuration file already exists at {} - not overwritting it.",
-        fs.file_write(&pathbuf, include_str!("../default.toml"))
+                    file_name
-            .with_context(|| format!("Writing file: {pathbuf:?}"))?;
+                );
-        println!("Created a default configuration file at {pathbuf:?}");
+            } else {
+                match fs.file_write(&pathbuf, include_str!("../default.toml")) {
+                    Ok(_) => {
+                        println!("Created a default configuration file at {}", file_name);
+                    }
+                    Err(e) => {
+                        eprintln!("Failed to write to the configuration file: {}", e)
+                    }
+                }
+            }
+        }
+        Err(err) => {
+            eprintln!("Could not check if file exist: {} - {err:?}", file_name);
+        }
     }
-    Ok(())
 }

crates/cli/src/main.rs

@@ -13,7 +13,6 @@ use git_next_core::git;
 
 use std::path::PathBuf;
 
-use anyhow::Result;
 use clap::Parser;
 use kxio::{fs, network::Network};
 
@@ -35,7 +34,7 @@ enum Server {
     Start,
 }
 
-fn main() -> Result<()> {
+fn main() {
     let fs = fs::new(PathBuf::default());
     let net = Network::new_real();
     let repository_factory = git::repository::factory::real();
@@ -43,17 +42,16 @@ fn main() -> Result<()> {
 
     match commands.command {
         Command::Init => {
-            init::run(fs)?;
+            init::run(fs);
         }
         Command::Server(server) => match server {
             Server::Init => {
-                server::init(fs)?;
+                server::init(fs);
             }
             Server::Start => {
                 let sleep_duration = std::time::Duration::from_secs(10);
-                server::start(fs, net, repository_factory, sleep_duration)?;
+                server::start(fs, net, repository_factory, sleep_duration);
             }
         },
     }
-    Ok(())
 }

crates/cli/src/server/actor/handlers/file_updated.rs

@@ -12,13 +12,13 @@ impl Handler<FileUpdated> for ServerActor {
     type Result = ();
 
     fn handle(&mut self, _msg: FileUpdated, ctx: &mut Self::Context) -> Self::Result {
-        match ServerConfig::load(&self.fs) {
+        let server_config = match ServerConfig::load(&self.fs) {
-            Ok(server_config) => {
+            Ok(server_config) => server_config,
-                self.do_send(ReceiveServerConfig::new(server_config), ctx);
-            }
             Err(err) => {
-                self.abort(ctx, format!("Failed to load config file. Error: {}", err));
+                tracing::error!("Failed to load config file. Error: {}", err);
+                return;
             }
         };
+        self.do_send(ReceiveServerConfig::new(server_config), ctx);
     }
 }

crates/cli/src/server/actor/handlers/receive_server_config.rs

@@ -12,15 +12,18 @@ impl Handler<ReceiveServerConfig> for ServerActor {
     fn handle(&mut self, msg: ReceiveServerConfig, ctx: &mut Self::Context) -> Self::Result {
         tracing::info!("recieved server config");
         let Ok(socket_addr) = msg.http() else {
-            self.abort(ctx, "Unable to parse http.addr");
+            tracing::error!("Unable to parse http.addr");
+            return;
         };
 
         let Some(server_storage) = self.server_storage(&msg) else {
-            self.abort(ctx, "Server storage not available");
+            tracing::error!("Server storage not available");
+            return;
         };
 
         if msg.inbound_webhook().base_url().ends_with('/') {
-            self.abort(ctx, "webhook.url must not end with a '/'");
+            tracing::error!("webhook.url must not end with a '/'");
+            return;
         }
 
         self.do_send(

crates/cli/src/server/actor/mod.rs

@@ -229,19 +229,6 @@ impl ServerActor {
         Some(server_storage)
     }
 
-    /// Attempts to gracefully shutdown the server before terminating the process.
-    fn abort(
-        &mut self,
-        ctx: &mut <Self as actix::Actor>::Context,
-        message: impl Into<String>,
-    ) -> ! {
-        tracing::error!("Aborting: {}", message.into());
-        self.do_send(crate::server::actor::messages::Shutdown, ctx);
-        std::thread::sleep(std::time::Duration::from_millis(200));
-        System::current().stop();
-        std::process::exit(-1);
-    }
-
     fn do_send<M>(&mut self, msg: M, _ctx: &mut <Self as actix::Actor>::Context)
     where
         M: actix::Message + Send + 'static + std::fmt::Debug,

crates/cli/src/server/mod.rs

@@ -10,26 +10,31 @@ use crate::file_watcher::{watch_file, FileUpdated};
 use actor::ServerActor;
 use git_next_core::git::RepositoryFactory;
 
-use anyhow::{Context, Result};
 use kxio::{fs::FileSystem, network::Network};
 use tracing::info;
 
 use std::path::PathBuf;
 
-pub fn init(fs: FileSystem) -> Result<()> {
+pub fn init(fs: FileSystem) {
     let file_name = "git-next-server.toml";
     let pathbuf = PathBuf::from(file_name);
-    if fs
+    let Ok(exists) = fs.path_exists(&pathbuf) else {
-        .path_exists(&pathbuf)
+        eprintln!("Could not check if file exist: {}", file_name);
-        .with_context(|| format!("Checking for existing file: {pathbuf:?}"))?
+        return;
-    {
+    };
-        eprintln!("The configuration file already exists at {pathbuf:?} - not overwritting it.",);
+    if exists {
+        eprintln!(
+            "The configuration file already exists at {} - not overwritting it.",
+            file_name
+        );
     } else {
-        fs.file_write(&pathbuf, include_str!("server-default.toml"))
+        match fs.file_write(&pathbuf, include_str!("server-default.toml")) {
-            .with_context(|| format!("Writing file: {pathbuf:?}"))?;
+            Ok(_) => println!("Created a default configuration file at {}", file_name),
-        println!("Created a default configuration file at {pathbuf:?}",);
+            Err(e) => {
+                eprintln!("Failed to write to the configuration file: {}", e)
+            }
+        }
     }
-    Ok(())
 }
 
 pub fn start(
@@ -37,7 +42,7 @@ pub fn start(
     net: Network,
     repo: Box<dyn RepositoryFactory>,
     sleep_duration: std::time::Duration,
-) -> Result<()> {
+) {
     init_logging();
 
     let execution = async move {
@@ -46,10 +51,7 @@ pub fn start(
         server.do_send(FileUpdated);
 
         info!("Starting File Watcher...");
-        #[allow(clippy::expect_used)]
+        watch_file("git-next-server.toml".into(), server.clone().recipient()).await;
-        watch_file("git-next-server.toml".into(), server.clone().recipient())
-            .await
-            .expect("file watcher");
 
         info!("Server running - Press Ctrl-C to stop...");
         let _ = actix_rt::signal::ctrl_c().await;
@@ -60,8 +62,9 @@ pub fn start(
     };
     let system = System::new();
     Arbiter::current().spawn(execution);
-    system.run()?;
+    if let Err(err) = system.run() {
-    Ok(())
+        tracing::error!(?err, "")
+    };
 }
 
 pub fn init_logging() {

crates/cli/src/tests.rs

@@ -8,7 +8,7 @@ mod init {
         let file = fs.base().join(".git-next.toml");
         fs.file_write(&file, "contents")?;
 
-        crate::init::run(fs.clone())?;
+        crate::init::run(fs.clone());
 
         assert_eq!(
             fs.file_read_to_string(&file)?,
@@ -23,7 +23,7 @@ mod init {
     fn should_create_default_file_if_not_exists() -> TestResult {
         let fs = kxio::fs::temp()?;
 
-        crate::init::run(fs.clone())?;
+        crate::init::run(fs.clone());
 
         let file = fs.base().join(".git-next.toml");