Created infrastructure for language server entry point

Author: IsaacShelton

src/adept/src/main.rs

@@ -1,4 +1,4 @@
-use daemon::daemonize_main;
+use daemon::{connect_to_daemon, server_main, try_become_daemon};
 use std::{iter::Peekable, process::ExitCode, time::Duration};
 
 fn main() -> ExitCode {
@@ -7,7 +7,9 @@ fn main() -> ExitCode {
     match args.peek().map(String::as_str) {
         Some("-h" | "--help") | None => show_help(),
         Some("--server") => start_server(),
+        Some("--daemon") => start_daemon(args),
         Some("--oneshot") => start_oneshot(args),
+        Some("--language-server") => start_language_server(args),
         _ => start_server(),
     }
 }
@@ -18,11 +20,35 @@ fn show_help() -> ExitCode {
 }
 
 fn start_server() -> ExitCode {
-    let path = std::env::current_dir().unwrap();
+    let connection = match connect_to_daemon() {
+        Ok(connection) => connection,
+        Err(err) => {
+            eprintln!("{}", err);
+            return ExitCode::FAILURE;
+        }
+    };
+
+    println!("Connected! {:?}", connection);
+    ExitCode::SUCCESS
+}
+
+fn start_daemon(_args: Peekable<impl Iterator<Item = String>>) -> ExitCode {
+    let path = std::env::current_dir().expect("failed to get current directory");
     let max_idle_time = Duration::from_secs(5 * 60);
-    daemonize_main(path, max_idle_time)
+
+    match try_become_daemon(&path.clone(), || server_main(max_idle_time)) {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(err) => {
+            eprintln!("{}", err);
+            ExitCode::FAILURE
+        }
+    }
 }
 
 fn start_oneshot(_args: Peekable<impl Iterator<Item = String>>) -> ExitCode {
     todo!()
 }
+
+fn start_language_server(_args: Peekable<impl Iterator<Item = String>>) -> ExitCode {
+    todo!()
+}

src/components/daemon/src/error.rs

@@ -0,0 +1,21 @@
+use std::fmt::Display;
+
+pub enum StartError {
+    IoError(std::io::Error),
+    FailedToStart,
+}
+
+impl From<std::io::Error> for StartError {
+    fn from(value: std::io::Error) -> Self {
+        Self::IoError(value)
+    }
+}
+
+impl Display for StartError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StartError::IoError(error) => write!(f, "{}", error),
+            StartError::FailedToStart => write!(f, "Failed to start daemon"),
+        }
+    }
+}

src/components/daemon/src/lib.rs

@@ -1,49 +1,31 @@
+mod error;
 mod idle;
 mod lockfile;
 mod serve;
 mod server;
 mod startup;
 mod watch;
 
-use crate::{
-    server::server_main,
-    startup::{spawn_daemon_process, try_become_daemon},
-};
-use std::{path::PathBuf, process::ExitCode, thread, time::Duration};
-
-pub fn daemonize_main(path: PathBuf, max_idle_time: Duration) -> ExitCode {
-    match start(path, max_idle_time) {
-        Ok(()) => ExitCode::SUCCESS,
-        Err(err) => {
-            eprintln!("{}", err);
-            ExitCode::FAILURE
-        }
-    }
-}
-
-fn start(path: PathBuf, max_idle_time: Duration) -> std::io::Result<()> {
-    let args: Vec<String> = std::env::args().collect();
-    if args.contains(&"--daemon".into()) {
-        return try_become_daemon(&path.clone(), || server_main(max_idle_time));
-    }
+pub use error::*;
+pub use server::*;
+pub use startup::*;
+use std::{net::TcpStream, thread, time::Duration};
 
+pub fn connect_to_daemon() -> Result<TcpStream, StartError> {
     // Try connecting to existing instance
-    if std::net::TcpStream::connect("127.0.0.1:6000").is_ok() {
+    if let Ok(connection) = std::net::TcpStream::connect("127.0.0.1:6000") {
         println!("Connected to existing daemon.");
-        return Ok(());
+        return Ok(connection);
     }
 
-    println!("No daemon found, launching one...");
     spawn_daemon_process()?;
 
     for _ in 0..10 {
-        if std::net::TcpStream::connect("127.0.0.1:6000").is_ok() {
-            println!("Daemon started!");
-            return Ok(());
+        if let Ok(connection) = std::net::TcpStream::connect("127.0.0.1:6000") {
+            return Ok(connection);
         }
-        thread::sleep(Duration::from_millis(200));
+        thread::sleep(Duration::from_millis(20));
     }
 
-    eprintln!("Failed to start daemon.");
-    Ok(())
+    Err(StartError::FailedToStart)
 }

src/components/req/src/lib.rs

@@ -38,7 +38,11 @@ macro_rules! log {
         $crate::log!("\n")
     };
     ($($arg:tt)*) => {{
-        eprintln!($($arg)*);
+        if true {
+            eprintln!($($arg)*);
+        } else {
+            let _ = format_args!($($arg)*);
+        }
     }};
 }