feat: chunk responses from daemon instead of sending entire payload

core/Cargo.toml

@@ -10,6 +10,7 @@ derive_more.workspace = true
 serde_json.workspace = true
 serde.workspace = true
 tokio.workspace = true
+tracing.workspace = true
 uuid.workspace = true
 
 bincode = "2.0.1"

core/src/lib.rs

@@ -5,5 +5,4 @@ pub mod error;
 pub mod events;
 pub mod messages;
 mod prelude;
-pub mod rand;
 pub mod states;

core/src/messages/request.rs

@@ -1,19 +1,16 @@
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::{
-    messages::{
-        response,
-        traits::{Message, RequestBody},
-    },
-    rand,
+use crate::messages::{
+    response,
+    traits::{Message, RequestBody},
 };
 
 // --------- serialized from the client ---------  //
 
 #[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 pub struct CliRequestMessage<T: RequestBody> {
-    pub id: u32,
+    pub id: Uuid,
     pub body: T,
 }
 impl<T: RequestBody + Serialize + for<'de> Deserialize<'de>> Message for CliRequestMessage<T> {}
@@ -22,7 +19,7 @@ impl<T: RequestBody + Serialize + for<'de> Deserialize<'de>> Message for CliRequ
 
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct DaemonRequestMessage {
-    pub id: u32,
+    pub id: Uuid,
     pub body: DaemonRequestMessageBody,
 }
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
@@ -51,14 +48,14 @@ pub type BodySet<T> = T;
 
 #[derive(Debug)]
 pub struct RequestBuilder<BodyState> {
-    id: u32,
+    id: Uuid,
     body: BodyState,
 }
 
 impl Default for RequestBuilder<BodyUnset> {
     fn default() -> Self {
         Self {
-            id: rand::generate_id(),
+            id: Uuid::new_v4(),
             body: BodyUnset,
         }
     }

core/src/messages/response.rs

@@ -1,10 +1,11 @@
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 
-use crate::{messages::traits::Message, rand, states::DaemonState};
+use crate::{messages::traits::Message, states::DaemonState};
 
 #[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 pub struct ResponseMessage<T> {
-    pub id: u32,
+    pub id: Uuid,
     pub result: ResponseResult<T>,
 }
 impl<T: Serialize + for<'de> Deserialize<'de>> Message for ResponseMessage<T> {}
@@ -29,14 +30,14 @@ pub struct ResultUnset;
 pub type ResultSet<T> = ResponseResult<T>;
 
 pub struct ResponseBuilder<ResultState> {
-    id: u32,
+    id: Uuid,
     result: ResultState,
 }
 
 impl Default for ResponseBuilder<ResultUnset> {
     fn default() -> Self {
         Self {
-            id: rand::generate_id(),
+            id: Uuid::new_v4(),
             result: ResultUnset,
         }
     }

core/src/prelude.rs

@@ -1,2 +1,4 @@
 #![allow(unused)]
+pub use tracing::{debug, error, info, trace, warn};
+
 pub use crate::error::{Error, Result};

daemon/src/actors/client_connection.rs

@@ -118,7 +118,10 @@ impl ClientConnection {
                                     comm::send_event(&mut self.stream, DaemonEvent::Disconnected).await.unwrap();
                                 }
                                 SessionOutput(bytes) => {
-                                    comm::send_event(&mut self.stream, DaemonEvent::Raw(bytes)).await.unwrap();
+                                    let chunk_size = 1024;
+                                    for chunk in bytes.chunks(chunk_size) {
+                                        comm::send_event(&mut self.stream, DaemonEvent::Raw(Bytes::copy_from_slice(chunk))).await.unwrap();
+                                    }
                                 }
                                 NewSession(session_id, session_name) => {
                                     comm::send_event(&mut self.stream, DaemonEvent::NewSession(session_id, session_name)).await.unwrap();