feat(daemon): ensure new projects server support

kkharji · kkharji · commit 38f14e4c3de8 · 2022-05-18T11:58:23.000+03:00
diff --git a/src/compile.rs b/src/compile.rs
@@ -178,3 +178,91 @@ pub async fn ensure_server_config(root: &path::PathBuf) -> Result<()> {
 
     Ok(())
 }
+
+#[cfg(feature = "daemon")]
+pub async fn ensure_server_support<'a>(
+    state: &'a mut tokio::sync::OwnedMutexGuard<crate::state::State>,
+    name: &String,
+    root: &std::path::PathBuf,
+    path: Option<&std::path::PathBuf>,
+) -> Result<bool> {
+    use crate::{error::XcodeGenError, xcodegen};
+    use tokio::fs::metadata;
+    let compile_exists = metadata(root.join(".compile")).await.is_ok();
+
+    if ensure_server_config(&root).await.is_err() {
+        "fail to ensure build server configuration!"
+            .pipe(|msg| state.clients.echo_err(&root, &name, msg))
+            .await;
+    }
+
+    if let Some(path) = path {
+        let generated = match xcodegen::regenerate(path, &root).await {
+            Ok(generated) => generated,
+            Err(e) => {
+                state.clients.echo_err(&root, &name, &e.to_string()).await;
+                return Err(e);
+            }
+        };
+
+        if generated {
+            state.projects.get_mut(root)?.update().await?
+        }
+    } else if compile_exists {
+        return Ok(false);
+    }
+
+    if xcodegen::is_valid(&root) && path.is_none() {
+        "⚙ generating xcodeproj ..."
+            .pipe(|msg| state.clients.echo_msg(&root, &name, msg))
+            .await;
+
+        if let Some(err) = match xcodegen::generate(&root).await {
+            Ok(status) => {
+                if status.success() {
+                    "setup: ⚙ generate xcodeproj ..."
+                        .pipe(|msg| state.clients.echo_msg(&root, &name, msg))
+                        .await;
+                    None
+                } else {
+                    Some(XcodeGenError::XcodeProjUpdate(name.into()).into())
+                }
+            }
+            Err(e) => Some(e),
+        } {
+            let msg = format!("fail to generate xcodeproj: {err}");
+            state.clients.echo_err(&root, &name, &msg).await;
+        }
+    };
+
+    // TODO(compile): check for .xcodeproj if project.yml is not generated
+    if !compile_exists {
+        "⚙ generating compile database .."
+            .pipe(|msg| state.clients.echo_msg(&root, &name, msg))
+            .await;
+    }
+
+    // The following command won't successed if this file doesn't exists
+    if let Err(err) = update_compilation_file(&root).await {
+        "setup: fail to regenerate compilation database!"
+            .pipe(|msg| state.clients.echo_err(&root, &name, msg))
+            .await;
+
+        use crate::util::proc_exists;
+        for (pid, client) in state.clients.iter() {
+            if proc_exists(pid, || {}) {
+                let mut logger = client.new_logger("Compile Error", name, &None);
+                logger.set_running().await.ok();
+                let ref win = Some(logger.open_win().await?);
+                logger.log(err.to_string(), win).await.ok();
+                logger.set_status_end(false, true).await.ok();
+            }
+        }
+
+        return Err(err);
+    }
+
+    tracing::info!("Updated `{name}/.compile`");
+
+    Ok(true)
+}
diff --git a/src/daemon/requests/register.rs b/src/daemon/requests/register.rs
@@ -1,6 +1,5 @@
-use crate::types::Client;
-
 use super::*;
+use crate::types::Client;
 
 /// Register new client with workspace
 #[derive(Debug, Serialize, Deserialize)]
@@ -21,39 +20,52 @@ impl<'a> Requester<'a, Register> for Register {
 impl Handler for Register {
     async fn handle(self) -> Result<()> {
         use crate::constants::DAEMON_STATE;
+        use tap::Pipe;
 
-        let Register { client, .. } = &self;
-        let Client { root, pid } = &client;
+        // NOTE: This logic should maybe moved to tokio::spawn to speed up initialization.
+        let name = self.client.abbrev_root();
+        tracing::info!("Register({}, {}): ", self.client.pid, name);
 
-        tracing::info!("Register({pid}, {}): ", client.abbrev_root());
+        let mut state = DAEMON_STATE.clone().lock_owned().await;
 
-        let state = DAEMON_STATE.clone();
-        let mut state = state.lock().await;
-
-        if let Ok(project) = state.projects.get_mut(root) {
+        if let Ok(project) = state.projects.get_mut(&self.client.root) {
             // NOTE: Add client pid to project
-            project.clients.push(*pid);
+            project.clients.push(self.client.pid.clone());
         } else {
             // NOTE: Create nvim client
             state.projects.add(&self).await?;
 
-            let project = state.projects.get(root).unwrap();
+            let project = state.projects.get(&self.client.root).unwrap();
             let ignore_patterns = project.ignore_patterns.clone();
 
             // NOTE: Add watcher
             state
                 .watcher
-                .add_project_watcher(client, ignore_patterns)
+                .add_project_watcher(&self.client, ignore_patterns)
                 .await
         }
 
         // NOTE: Create nvim client
         state.clients.add(&self).await?;
 
-        // NOTE: Sink Daemon to nvim vim.g.xbase.state
-        let _update_handle = state.sync_client_state().await?;
+        tokio::spawn(async move {
+            let ref mut state = DAEMON_STATE.clone().lock_owned().await;
+
+            // NOTE: Ensure project is ready for xbase build server
+            let generated =
+                crate::compile::ensure_server_support(state, &name, &self.client.root, None)
+                    .await?;
+
+            if generated {
+                "setup: ✅"
+                    .pipe(|msg| state.clients.echo_msg(&self.client.root, &name, msg))
+                    .await;
+            }
 
-        // TODO(register): Ensure buildServer.json and .compile exists in a subprocess
+            // NOTE: Sink Daemon to nvim vim.g.xbase
+            state.sync_client_state().await?;
+            anyhow::Ok(())
+        });
 
         Ok(())
     }
diff --git a/src/watcher/handle/project.rs b/src/watcher/handle/project.rs
@@ -1,5 +1,5 @@
 use super::{is_seen, WatchArguments, WatchError};
-use crate::{compile, Error};
+use crate::compile;
 use crate::{constants::DAEMON_STATE, types::Client};
 use notify::event::{DataChange, ModifyKind};
 use notify::{Event, EventKind};
@@ -20,168 +20,75 @@ pub async fn create(args: WatchArguments) -> Result<(), WatchError> {
     let Client { root, .. } = info.try_into_project()?;
 
     if should_skip_compile(&event, &path, args.last_seen).await {
-        tracing::trace!("Skipping {:#?}", &event);
         return Ok(());
     }
 
-    tracing::trace!("[NewEvent] {:#?}", &event);
-
-    let state = DAEMON_STATE.clone();
-    let mut state = state.lock().await;
+    let ref name = root.file_name().unwrap().to_string_lossy().to_string();
+    let ref mut state = DAEMON_STATE.clone().lock_owned().await;
     let mut debounce = args.debounce.lock().await;
 
-    let project_name = root.file_name().unwrap().to_string_lossy().to_string();
+    state.clients.echo_msg(&root, name, START_MSG).await;
 
-    echo_messsage_to_clients(&state, root, &project_name, START_MSG).await;
-
-    {
-        let res = try_updating_project_state(&mut state, &path, root, &project_name).await;
-        if res.is_err() {
-            *debounce = std::time::SystemTime::now();
-            res?;
-        }
-    }
-
-    ensure_server_configuration(&state, root, &project_name).await;
-
-    if let Err(e) = generate_compiled_commands(&state, root, &project_name).await {
+    if let Err(e) = compile::ensure_server_support(state, name, root, Some(&path)).await {
         *debounce = std::time::SystemTime::now();
         return Err(e.into());
     }
 
-    echo_messsage_to_clients(&state, root, &project_name, SUCC_MESSAGE).await;
+    state.clients.echo_msg(&root, name, SUCC_MESSAGE).await;
 
     *debounce = std::time::SystemTime::now();
 
     Ok(())
 }
 
-async fn try_updating_project_state<'a>(
-    state: &mut tokio::sync::MutexGuard<'a, crate::state::State>,
-    path: &PathBuf,
-    root: &PathBuf,
-    project_name: &String,
-) -> Result<(), WatchError> {
-    let generated = match crate::xcodegen::regenerate(path, &root).await {
-        Ok(generated) => generated,
-        Err(e) => {
-            echo_error_to_clients(state, root, project_name, &e.to_string()).await;
-            return Ok(());
-        }
-    };
-
-    if generated {
-        state.projects.get_mut(root)?.update().await?
-    }
-
-    Ok(())
-}
-
-async fn ensure_server_configuration<'a>(
-    state: &'a tokio::sync::MutexGuard<'a, crate::state::State>,
-    root: &PathBuf,
-    project_name: &String,
-) {
-    if compile::ensure_server_config(&root).await.is_err() {
-        echo_error_to_clients(
-            state,
-            &root,
-            project_name,
-            "Fail to ensure build server configuration!",
-        )
-        .await;
-    }
-}
-
-async fn generate_compiled_commands<'a>(
-    state: &'a tokio::sync::MutexGuard<'a, crate::state::State>,
-    root: &PathBuf,
-    project_name: &String,
-) -> Result<(), Error> {
-    if let Err(err) = compile::update_compilation_file(&root).await {
-        echo_error_to_clients(
-            state,
-            &root,
-            project_name,
-            "Fail to regenerate compilation database!",
-        )
-        .await;
-
-        // use crate::util::proc_exists;
-        // for (pid, client) in state.clients.iter() {
-        //     if proc_exists(pid, || {}) {
-        //         let mut logger = client.new_logger("Compile Error", project_name, &None);
-        //         logger.set_running().await.ok();
-        //         let ref win = Some(logger.open_win().await.map_err(WatchError::r#continue)?);
-        //         logger.log(err.to_string(), win).await.ok();
-        //         logger.set_status_end(false, true).await.ok();
-        //     }
-        // }
-        return Err(err);
-    }
-
-    tracing::info!("Updated `{project_name}/.compile`");
-
-    Ok(())
-}
-
-async fn echo_messsage_to_clients<'a>(
-    state: &tokio::sync::MutexGuard<'a, crate::state::State>,
-    root: &PathBuf,
-    project_name: &String,
-    msg: &str,
-) {
-    state.clients.echo_msg(&root, project_name, msg).await;
-}
-
-async fn echo_error_to_clients<'a>(
-    state: &tokio::sync::MutexGuard<'a, crate::state::State>,
-    root: &PathBuf,
-    project_name: &String,
-    msg: &str,
-) {
-    state.clients.echo_err(&root, project_name, msg).await;
-}
-
 async fn should_skip_compile(event: &Event, path: &PathBuf, last_seen: Arc<Mutex<String>>) -> bool {
-    match &event.kind {
+    tracing::trace!("[NewEvent] {:#?}", &event);
+
+    let skip = match &event.kind {
         EventKind::Create(_) => {
             tokio::time::sleep(Duration::new(1, 0)).await;
             tracing::debug!("[FileCreated]: {:?}", path);
+            false
         }
 
         EventKind::Remove(_) => {
             tokio::time::sleep(Duration::new(1, 0)).await;
             tracing::debug!("[FileRemoved]: {:?}", path);
+            false
         }
 
         EventKind::Modify(m) => match m {
             ModifyKind::Data(e) => match e {
                 DataChange::Content => {
                     if !path.display().to_string().contains("project.yml") {
-                        return true;
+                        true;
                     }
                     tokio::time::sleep(Duration::new(1, 0)).await;
                     tracing::debug!("[XcodeGenConfigUpdate]");
                     // HACK: Not sure why, but this is needed because xcodegen break.
+                    false
                 }
-                _ => return true,
+                _ => true,
             },
 
             ModifyKind::Name(_) => {
                 let path_string = path.to_string_lossy();
                 // HACK: only account for new path and skip duplications
                 if !path.exists() || is_seen(last_seen.clone(), &path_string).await {
-                    return true;
+                    true;
                 }
                 tokio::time::sleep(Duration::new(1, 0)).await;
                 tracing::debug!("[FileRenamed]: {:?}", path);
+                false
             }
-            _ => return true,
+            _ => true,
         },
 
-        _ => return true,
+        _ => true,
     };
 
-    false
+    if skip {
+        tracing::trace!("Skipping {:#?}", &event);
+    }
+    skip
 }
diff --git a/src/xcodegen.rs b/src/xcodegen.rs
