Refactor into grpc events

src-tauri/grpc/src/lib.rs

@@ -1,11 +1,15 @@
-use prost_reflect::{DynamicMessage, SerializeOptions};
+use prost_reflect::{DynamicMessage, MethodDescriptor, SerializeOptions};
 use serde::{Deserialize, Serialize};
+use serde_json::Deserializer;
 
 mod codec;
 mod json_schema;
 pub mod manager;
 mod proto;
 
+pub use tonic::metadata::*;
+pub use tonic::Code;
+
 pub fn serialize_options() -> SerializeOptions {
     SerializeOptions::new().skip_default_fields(false)
 }
@@ -38,3 +42,11 @@ pub fn serialize_message(msg: &DynamicMessage) -> Result<String, String> {
     let s = String::from_utf8(buf).expect("serde_json to emit valid utf8");
     Ok(s)
 }
+
+pub fn deserialize_message(msg: &str, method: MethodDescriptor) -> Result<DynamicMessage, String> {
+    let mut deserializer = Deserializer::from_str(&msg);
+    let req_message = DynamicMessage::deserialize(method.input(), &mut deserializer)
+        .map_err(|e| e.to_string())?;
+    deserializer.end().map_err(|e| e.to_string())?;
+    Ok(req_message)
+}

src-tauri/grpc/src/manager.rs

@@ -9,7 +9,6 @@ pub use prost_reflect::DynamicMessage;
 use prost_reflect::{DescriptorPool, MethodDescriptor, ServiceDescriptor};
 use serde_json::Deserializer;
 use tokio_stream::wrappers::ReceiverStream;
-use tokio_stream::StreamExt;
 use tonic::body::BoxBody;
 use tonic::metadata::{MetadataKey, MetadataValue};
 use tonic::transport::Uri;
@@ -50,7 +49,7 @@ impl GrpcConnection {
         method: &str,
         message: &str,
         metadata: HashMap<String, String>,
-    ) -> Result<DynamicMessage, String> {
+    ) -> Result<Response<DynamicMessage>, String> {
         let method = &self.method(&service, &method)?;
         let input_message = method.input();
 
@@ -68,34 +67,23 @@ impl GrpcConnection {
         let codec = DynamicCodec::new(method.clone());
         client.ready().await.unwrap();
 
-        Ok(client
+        client
             .unary(req, path, codec)
             .await
-            .map_err(|e| e.to_string())?
-            .into_inner())
+            .map_err(|e| e.to_string())
     }
 
     pub async fn streaming(
         &self,
         service: &str,
         method: &str,
-        stream: ReceiverStream<String>,
+        stream: ReceiverStream<DynamicMessage>,
         metadata: HashMap<String, String>,
     ) -> Result<Result<Response<Streaming<DynamicMessage>>, Status>, String> {
         let method = &self.method(&service, &method)?;
         let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
 
-        let method2 = method.clone();
-        let mut req = stream
-            .map(move |s| {
-                let mut deserializer = Deserializer::from_str(&s);
-                let req_message = DynamicMessage::deserialize(method2.input(), &mut deserializer)
-                    .map_err(|e| e.to_string())
-                    .unwrap();
-                deserializer.end().unwrap();
-                req_message
-            })
-            .into_streaming_request();
+        let mut req = stream.into_streaming_request();
 
         decorate_req(metadata, &mut req).map_err(|e| e.to_string())?;
 
@@ -109,37 +97,21 @@ impl GrpcConnection {
         &self,
         service: &str,
         method: &str,
-        stream: ReceiverStream<String>,
+        stream: ReceiverStream<DynamicMessage>,
         metadata: HashMap<String, String>,
-    ) -> Result<DynamicMessage, String> {
+    ) -> Result<Response<DynamicMessage>, String> {
         let method = &self.method(&service, &method)?;
         let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
-
-        let mut req = {
-            let method = method.clone();
-            stream
-                .map(move |s| {
-                    let mut deserializer = Deserializer::from_str(&s);
-                    let req_message =
-                        DynamicMessage::deserialize(method.input(), &mut deserializer)
-                            .map_err(|e| e.to_string())
-                            .unwrap();
-                    deserializer.end().unwrap();
-                    req_message
-                })
-                .into_streaming_request()
-        };
-
+        let mut req = stream.into_streaming_request();
         decorate_req(metadata, &mut req).map_err(|e| e.to_string())?;
 
         let path = method_desc_to_path(method);
         let codec = DynamicCodec::new(method.clone());
         client.ready().await.unwrap();
-        Ok(client
+        client
             .client_streaming(req, path, codec)
             .await
-            .map_err(|s| s.to_string())?
-            .into_inner())
+            .map_err(|s| s.to_string())
     }
 
     pub async fn server_streaming(
@@ -230,54 +202,6 @@ impl GrpcHandle {
             .collect::<Vec<_>>()
     }
 
-    pub async fn server_streaming(
-        &mut self,
-        id: &str,
-        uri: Uri,
-        proto_files: Vec<PathBuf>,
-        service: &str,
-        method: &str,
-        message: &str,
-        metadata: HashMap<String, String>,
-    ) -> Result<Result<Response<Streaming<DynamicMessage>>, Status>, String> {
-        self.connect(id, uri, proto_files)
-            .await?
-            .server_streaming(service, method, message, metadata)
-            .await
-    }
-
-    pub async fn client_streaming(
-        &mut self,
-        id: &str,
-        uri: Uri,
-        proto_files: Vec<PathBuf>,
-        service: &str,
-        method: &str,
-        stream: ReceiverStream<String>,
-        metadata: HashMap<String, String>,
-    ) -> Result<DynamicMessage, String> {
-        self.connect(id, uri, proto_files)
-            .await?
-            .client_streaming(service, method, stream, metadata)
-            .await
-    }
-
-    pub async fn streaming(
-        &mut self,
-        id: &str,
-        uri: Uri,
-        proto_files: Vec<PathBuf>,
-        service: &str,
-        method: &str,
-        stream: ReceiverStream<String>,
-        metadata: HashMap<String, String>,
-    ) -> Result<Result<Response<Streaming<DynamicMessage>>, Status>, String> {
-        self.connect(id, uri, proto_files)
-            .await?
-            .streaming(service, method, stream, metadata)
-            .await
-    }
-
     pub async fn connect(
         &mut self,
         id: &str,