fix: move agent.proto in root folder and use better error handling in…

… grpc service

Signed-off-by: Matéo Fernandez <[email protected]>

src/agent/build.rs

@@ -1,4 +1,4 @@
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    tonic_build::compile_protos("../proto/agent.proto")?;
+    tonic_build::compile_protos("../../proto/agent.proto")?;
     Ok(())
 }

src/agent/src/workload/service.rs

@@ -1,15 +1,11 @@
-use std::{process::exit, sync::Arc};
-
+use super::runner::Runner;
 use crate::agent::{self, ExecuteRequest, ExecuteResponse, SignalRequest};
-
 use agent::workload_runner_server::WorkloadRunner;
-
+use std::sync::Arc;
 use tokio::sync::Mutex;
 use tokio_stream::wrappers::ReceiverStream;
 use tonic::{Request, Response};
 
-use super::runner::Runner;
-
 type Result<T> = std::result::Result<Response<T>, tonic::Status>;
 
 pub struct WorkloadRunnerService {
@@ -18,7 +14,7 @@ pub struct WorkloadRunnerService {
 
 impl WorkloadRunnerService {
     pub fn new(runner: Runner) -> Self {
-        WorkloadRunnerService {
+        Self {
             runner: Arc::new(Mutex::new(runner)),
         }
     }
@@ -32,36 +28,32 @@ impl WorkloadRunner for WorkloadRunnerService {
         let (tx, rx) = tokio::sync::mpsc::channel(4);
 
         // We assume there's only one request at a time
-        let runner = match self.runner.try_lock() {
-            Ok(runner) => runner,
-            Err(_) => {
-                return Err(tonic::Status::unavailable("Runner is busy"));
-            }
-        };
-
-        let res = match runner.run() {
-            Ok(res) => res,
-            Err(err) => {
-                return Err(tonic::Status::internal(err.to_string()));
-            }
-        };
-
-        let _ = tx
-            .send(Ok(ExecuteResponse {
-                stdout: res.stdout,
-                stderr: res.stderr,
-                exit_code: res.exit_code,
-            }))
-            .await
-            .map_err(|e| {
-                println!("Failed to send response: {:?}", e);
-                tonic::Status::internal("Failed to send response")
-            })?;
+        let runner = self
+            .runner
+            .try_lock()
+            .map_err(|e| tonic::Status::unavailable(format!("Runner is busy: {:?}", e)))?;
+
+        let res = runner
+            .run()
+            .map_err(|e| tonic::Status::internal(e.to_string()))?;
+
+        tx.send(Ok(ExecuteResponse {
+            stdout: res.stdout,
+            stderr: res.stderr,
+            exit_code: res.exit_code,
+        }))
+        .await
+        .map_err(|e| {
+            println!("Failed to send response: {:?}", e);
+            tonic::Status::internal("Failed to send response")
+        })?;
 
         Ok(Response::new(ReceiverStream::new(rx)))
     }
 
     async fn signal(&self, _: Request<SignalRequest>) -> Result<()> {
-        unreachable!();
+        // should apply the given signal on the runner process
+        // example: kill the process if running
+        todo!();
     }
 }