Fix journal not closed on start failure and flush before raw

cli/src/args.rs

@@ -160,10 +160,10 @@ pub fn parse() -> CliResult<Task> {
 }
 
 fn read_password(prompt: &str) -> Result<String, std::io::Error> {
-    terminal::enable_raw_mode()?;
     print!("{prompt}");
     io::stdout().flush()?;
     let mut password = String::new();
+    terminal::enable_raw_mode()?;
     loop {
         match event::read()? {
             Event::Key(KeyEvent {

server/src/main.rs

@@ -68,36 +68,57 @@ fn main() {
         .parse_filters(&env::var("SKY_LOG").unwrap_or_else(|_| "info".to_owned()))
         .init();
     println!("{TEXT}\nSkytable v{VERSION} | {URL}\n");
+    entrypoint()
+}
+
+fn entrypoint() {
     let run = || {
+        let f_rt_start = || {
             engine::set_context_init("locking PID file");
             let pid_file = util::os::FileLock::new(SKY_PID_FILE)?;
+            engine::set_context_init("initializing runtime");
             let runtime = tokio::runtime::Builder::new_multi_thread()
                 .thread_name("server")
                 .enable_all()
-            .build()
+                .build()?;
-            .unwrap();
+            Ok((pid_file, runtime))
-        let g = runtime.block_on(async move {
+        };
+        let (pid_file, runtime) = match f_rt_start() {
+            Ok((pf, rt)) => (pf, rt),
+            Err(e) => return (None, None, Err(e)),
+        };
+        let f_glob_init = runtime.block_on(async move {
             engine::set_context_init("binding system signals");
             let signal = util::os::TerminationSignal::init()?;
             let (config, global) = tokio::task::spawn_blocking(|| engine::load_all())
                 .await
                 .unwrap()?;
+            engine::RuntimeResult::Ok((signal, config, global))
+        });
+        let (signal, config, global) = match f_glob_init {
+            Ok((sig, cfg, g)) => (sig, cfg, g),
+            Err(e) => return (Some(pid_file), None, Err(e)),
+        };
         let g = global.global.clone();
-            engine::start(signal, config, global).await?;
+        let result_start =
-            engine::RuntimeResult::Ok(g)
+            runtime.block_on(async move { engine::start(signal, config, global).await });
-        })?;
+        (Some(pid_file), Some(g), result_start)
-        engine::RuntimeResult::Ok((pid_file, g))
     };
-    match run() {
+    let (pid_file, global, result) = run();
-        Ok((_, g)) => {
+    if let Some(g) = global {
-            info!("completing cleanup before exit");
+        info!("cleaning up data");
         engine::finish(g);
-            std::fs::remove_file(SKY_PID_FILE).expect("failed to remove PID file");
-            println!("Goodbye!");
     }
+    if let Some(_) = pid_file {
+        if let Err(e) = std::fs::remove_file(SKY_PID_FILE) {
+            error!("failed to remove PID file: {e}");
+        }
+    }
+    match result {
+        Ok(()) => println!("goodbye"),
         Err(e) => {
             error!("{e}");
-            exit_error()
+            exit_error();
         }
     }
 }