ref: switch to tarpc framework

Author: kkharji

Cargo.lock

@@ -7,7 +7,7 @@ edition = "2021"
 
 # Internal
 log                   = { path = "./../log/" }
-xbase-proto           = { path = "./../proto/" }
+xbase-proto           = { path = "./../proto/", features = ["server"] }
 
 # Error Handling
 anyhow                = { version = "^1.0.58" }
@@ -20,9 +20,8 @@ serde_yaml            = { version = "0.8.23" }
 strum                 = { version = "0.24.0",  features = ["derive"] }
 
 # Async Runtime Feature
-tokio                 = { version = "1.17.0", features = ["full"] }
+tokio                 = { version = "1.19.2", features = ["full"] }
 futures               = { version = "0.3.21" }
-tokio-util            = { version = "0.7.1",  features = ["codec"] }
 async-trait           = { version = "0.1.52" }
 async-stream          = { version = "0.3.3" }
 parity-tokio-ipc      = { version = "0.9.0" }
@@ -43,7 +42,7 @@ nvim-rs               = { version = "0.4.0", features = ["use_tokio"] }
 # Other
 tap                   = "1.0.1"
 xclog                 = { version  = "0.2.*",  features = ["with_tracing"] }
-simctl                = { git = "https://github.com/tami5/simctl" }
+simctl                = { git = "https://github.com/xbase-lab/simctl" }
 derive-deref-rs       = { version = "0.1.1"}
 shell-words           = { version  = "1.1.0" }
 
@@ -53,3 +52,4 @@ libproc               = { version = "0.12.0" }
 paste = "1.0.7"
 which = "4.2.5"
 erased-serde = "0.3.21"
+tarpc = { version = "0.29.0", features = ["serde-transport", "tokio1", "serde1"] }

daemon/Cargo.toml

@@ -3,7 +3,6 @@ pub mod compile;
 pub mod constants;
 pub mod device;
 pub mod drop;
-pub mod error;
 pub mod nvim;
 pub mod project;
 pub mod register;
@@ -13,11 +12,10 @@ pub mod store;
 pub mod util;
 pub mod watch;
 
-pub use error::{CompileError, Error, LoopError};
 use process_stream::{ProcessItem, Stream};
 use std::pin::Pin;
 
-pub type Result<T> = std::result::Result<T, Error>;
+pub use xbase_proto::{Error, IntoResult, Result};
 pub type OutputStream = Pin<Box<dyn Stream<Item = ProcessItem> + Send>>;
 pub type StringStream = Pin<Box<dyn Stream<Item = String> + Send>>;
 

daemon/src/error.rs

@@ -1,70 +1,69 @@
 use log::Level;
+use std::path::PathBuf;
 use tap::Pipe;
 use tokio::fs::{metadata, read_to_string, remove_file, write};
-use tokio::io::AsyncReadExt;
 use tokio::net::UnixListener;
 use xbase::util::pid;
-use xbase::Result;
 use xbase::{constants::*, RequestHandler};
-use xbase_proto::{Message, Request};
+use xbase_proto::*;
 
+#[derive(Clone)]
+struct Server;
+
+#[tarpc::server]
+impl xbase_proto::XBase for Server {
+    /// Register project root with a path to setup logs
+    async fn register(self, _: Context, req: RegisterRequest) -> Result<PathBuf> {
+        req.handle().await?;
+        Ok("/bin/cp".into())
+    }
+    /// Build Project and get path to where to build log will be located
+    async fn build(self, _: Context, req: BuildRequest) -> Result<PathBuf> {
+        // NOTE: Required because of nvim-rs
+        tokio::spawn(async { req.handle().await });
+        Ok(PathBuf::default())
+    }
+    /// Run Project and get path to where to Runtime log will be located
+    async fn run(self, _: Context, req: RunRequest) -> Result<PathBuf> {
+        // NOTE: Required because of nvim-rs
+        tokio::spawn(async { req.handle().await });
+        Ok(PathBuf::default())
+    }
+    /// Drop project root
+    async fn drop(self, _: Context, req: DropRequest) -> Result<()> {
+        // NOTE: Required because of nvim-rs
+        tokio::spawn(async { req.handle().await });
+        Ok(())
+    }
+}
 #[tokio::main]
-async fn main() -> Result<()> {
+async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
     ensure_single_instance().await?;
 
     let listener = UnixListener::bind(DAEMON_SOCKET_PATH).unwrap();
-
+    let codec_builder = LengthDelimitedCodec::builder();
     log::setup("/tmp", "xbase-daemon.log", Level::DEBUG, true)?;
-
     log::info!("Started");
 
     loop {
-        if let Ok((mut s, _)) = listener.accept().await {
+        if let Ok((s, _)) = listener.accept().await {
             tokio::spawn(async move {
-                let msg = {
-                    let mut msg = String::default();
-                    if let Err(e) = s.read_to_string(&mut msg).await {
-                        return log::error!("[Read Error]: {:?}", e);
-                    };
-                    msg
-                };
-
-                if msg.is_empty() {
-                    return;
-                }
-
-                let req = match Request::read(msg.clone()) {
-                    Err(e) => {
-                        return log::error!("[Parse Error]: {:?} message: {msg}", e);
-                    }
-                    Ok(req) => req,
-                };
-
-                if let Err(e) = handle(req).await {
-                    return log::error!("[Failure]: Cause: ({:?})", e);
-                };
+                let framed = codec_builder.new_framed(s);
+                let transport = transport::new(framed, Json::default());
+                BaseChannel::with_defaults(transport)
+                    .execute(Server.serve())
+                    .await;
 
                 let state = DAEMON_STATE.clone();
                 let mut state = state.lock().await;
                 state.validate().await;
-
-                // update_watchers(state.clone()).await;
             });
         } else {
             log::error!("Fail to accept a connection")
         };
     }
 }
 
-async fn handle(req: Request) -> Result<()> {
-    match req.message {
-        Message::Build(c) => RequestHandler::handle(c).await,
-        Message::Run(c) => RequestHandler::handle(c).await,
-        Message::Register(c) => RequestHandler::handle(c).await,
-        Message::Drop(c) => RequestHandler::handle(c).await,
-    }
-}
-
 async fn ensure_single_instance() -> Result<()> {
     if metadata(DAEMON_SOCKET_PATH).await.ok().is_some() {
         remove_file(DAEMON_SOCKET_PATH).await.ok();

daemon/src/lib.rs

@@ -118,7 +118,7 @@ impl Project for BareboneProject {
         }
 
         if xcodeproj_paths.is_empty() {
-            return Err(Error::ProjectError("No XcodeProjectFound!".into()));
+            return Err(Error::DefinitionLocating);
         };
 
         project.xcodeproj = XCodeProject::new(&xcodeproj_paths[0])?;

daemon/src/main.rs

@@ -140,10 +140,7 @@ impl ProjectGenerate for SwiftProject {
         let (success, logs) = consume_and_log(process.spawn_and_stream()?.boxed()).await;
 
         if !success {
-            return Err(Error::SwiftBuildForComplilation(
-                self.name().into(),
-                logs.join("\n"),
-            ));
+            return Err(Error::Generate(logs.join("\n")));
         }
 
         self.update_project_info().await?;
@@ -202,14 +199,15 @@ impl SwiftProject {
             .await?;
 
         let map = if output.status.success() {
-            serde_json::from_slice::<Map<String, Value>>(&output.stdout)?
+            serde_json::from_slice::<Map<String, Value>>(&output.stdout)
+                .map_err(|e| Error::DefinitionParsing(e.to_string()))?
         } else {
             let error = String::from_utf8(output.stderr)
                 .unwrap_or_default()
                 .split("\n")
                 .collect();
             log::error!("Fail to read swift package information {error}");
-            return Err(Error::SwiftPackageRead(self.name().into(), error));
+            return Err(Error::DefinitionParsing(error));
         };
 
         // TODO(swift-package): only provide run service for executables

daemon/src/project/barebone.rs

@@ -183,10 +183,7 @@ impl TuistProject {
 
         let (success, logs) = consume_and_log(Box::pin(process.spawn_and_stream()?)).await;
         if !success {
-            return Err(Error::XCodeProjectGenerate(
-                "Project".into(),
-                logs.join("\n"),
-            ));
+            return Err(Error::Generate(logs.join("\n")));
         }
 
         Ok(())

daemon/src/project/swift.rs

@@ -108,10 +108,7 @@ impl ProjectGenerate for XCodeGenProject {
             self.xcodeproj = XCodeProject::new(&xcodeproj_paths[0])?;
             self.targets = self.xcodeproj.targets_platform();
         } else {
-            return Err(Error::XCodeProjectGenerate(
-                self.name().into(),
-                logs.join("\n"),
-            ));
+            return Err(Error::Generate(logs.join("\n")));
         }
 
         Ok(())