multiple rpc in one file

Author: indpurvesh

proto/misc.proto

@@ -10,9 +10,19 @@ message HealthCheckResponse {
     bool status = 1;
 }
 
+message SetupRequest {
+}
+
+message SetupResponse {
+    bool status = 1;
+}
+
 
-// Misc is a simple service that provides miscellaneous RPC methods.
+/// Misc is a simple service that provides miscellaneous RPC methods.
 service Misc {
-    // HealthCheck is a simple RPC method that can be used to check the health of the service.
+    /// HealthCheck is a simple RPC method that can be used to check the health of the service.
     rpc HealthCheck(HealthCheckRequest) returns (HealthCheckResponse);
+
+    /// Setup is a simple RPC method that can be used to setup the service.
+    rpc Setup(SetupRequest) returns (SetupResponse);
 }

src/infra/app.rs

@@ -1,16 +1,15 @@
-use axum::Router;
+use crate::infra::setup::AppState;
+use crate::pages::app::App;
+use crate::pages::shell::Shell;
 use axum::response::IntoResponse;
+use axum::Router;
 use leptos::config::LeptosOptions;
 use leptos::prelude::provide_context;
 use leptos_axum::{generate_route_list, LeptosRoutes};
 use tower::ServiceExt;
 use tower_http::services::ServeDir;
-use crate::infra::setup::AppState;
-use crate::pages::app::App;
-use crate::pages::shell::Shell;
 
 pub async fn create_app(state: AppState) -> crate::error::Result<Router> {
-
     let leptos_options = state.leptos_options.clone();
     // let leptos_options = state.leptos_options;
     // Generate the list of routes in your Leptos App
@@ -21,12 +20,12 @@ pub async fn create_app(state: AppState) -> crate::error::Result<Router> {
         crate::infra::grpc::helloworld::greeter_server::GreeterServer::new(my_hello_server);
 
     let my_misc_server = crate::infra::grpc::misc_server::MyMisc::default();
-    let my_misc_service =
-        crate::infra::grpc::misc::misc_server::MiscServer::new(my_misc_server);
+    let my_misc_service = crate::infra::grpc::misc::misc_server::MiscServer::new(my_misc_server);
 
     let router = Router::<AppState>::new()
         .route_service("/helloworld.Greeter/SayHello", my_hello_service)
-        .route_service("/misc.Misc/HealthCheck", my_misc_service)
+        .route_service("/misc.Misc/HealthCheck", my_misc_service.clone())
+        .route_service("/misc.Misc/Setup", my_misc_service)
         .leptos_routes_with_context(
             &state,
             routes,
@@ -43,15 +42,11 @@ pub async fn create_app(state: AppState) -> crate::error::Result<Router> {
             ServeDir::new(std::path::Path::new(&*leptos_options.site_root).join("pkg")),
         )
         .nest_service("/public", ServeDir::new(std::path::Path::new("public")))
-        
-        .fallback(file_and_error_handler)
-        ;
+        .fallback(file_and_error_handler);
 
     Ok(router.with_state(state))
-    
 }
 
-
 pub async fn file_and_error_handler(
     uri: axum::http::Uri,
     axum::extract::State(options): axum::extract::State<LeptosOptions>,
@@ -69,7 +64,6 @@ pub async fn file_and_error_handler(
     }
 }
 
-
 pub async fn get_static_file(
     uri: axum::http::Uri,
     root: &str,

src/infra/grpc/misc.rs

@@ -6,6 +6,13 @@ pub struct HealthCheckResponse {
     #[prost(bool, tag = "1")]
     pub status: bool,
 }
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct SetupRequest {}
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct SetupResponse {
+    #[prost(bool, tag = "1")]
+    pub status: bool,
+}
 /// Generated client implementations.
 pub mod misc_client {
     #![allow(
@@ -17,7 +24,7 @@ pub mod misc_client {
     )]
     use tonic::codegen::*;
     use tonic::codegen::http::Uri;
-    /// Misc is a simple service that provides miscellaneous RPC methods.
+    /// / Misc is a simple service that provides miscellaneous RPC methods.
     #[derive(Debug, Clone)]
     pub struct MiscClient<T> {
         inner: tonic::client::Grpc<T>,
@@ -98,7 +105,7 @@ pub mod misc_client {
             self.inner = self.inner.max_encoding_message_size(limit);
             self
         }
-        /// HealthCheck is a simple RPC method that can be used to check the health of the service.
+        /// / HealthCheck is a simple RPC method that can be used to check the health of the service.
         pub async fn health_check(
             &mut self,
             request: impl tonic::IntoRequest<super::HealthCheckRequest>,
@@ -120,6 +127,25 @@ pub mod misc_client {
             req.extensions_mut().insert(GrpcMethod::new("misc.Misc", "HealthCheck"));
             self.inner.unary(req, path, codec).await
         }
+        /// / Setup is a simple RPC method that can be used to setup the service.
+        pub async fn setup(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SetupRequest>,
+        ) -> std::result::Result<tonic::Response<super::SetupResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic_prost::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/misc.Misc/Setup");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new("misc.Misc", "Setup"));
+            self.inner.unary(req, path, codec).await
+        }
     }
 }
 /// Generated server implementations.
@@ -135,16 +161,21 @@ pub mod misc_server {
     /// Generated trait containing gRPC methods that should be implemented for use with MiscServer.
     #[async_trait]
     pub trait Misc: std::marker::Send + std::marker::Sync + 'static {
-        /// HealthCheck is a simple RPC method that can be used to check the health of the service.
+        /// / HealthCheck is a simple RPC method that can be used to check the health of the service.
         async fn health_check(
             &self,
             request: tonic::Request<super::HealthCheckRequest>,
         ) -> std::result::Result<
             tonic::Response<super::HealthCheckResponse>,
             tonic::Status,
         >;
+        /// / Setup is a simple RPC method that can be used to setup the service.
+        async fn setup(
+            &self,
+            request: tonic::Request<super::SetupRequest>,
+        ) -> std::result::Result<tonic::Response<super::SetupResponse>, tonic::Status>;
     }
-    /// Misc is a simple service that provides miscellaneous RPC methods.
+    /// / Misc is a simple service that provides miscellaneous RPC methods.
     #[derive(Debug)]
     pub struct MiscServer<T> {
         inner: Arc<T>,
@@ -264,6 +295,49 @@ pub mod misc_server {
                     };
                     Box::pin(fut)
                 }
+                "/misc.Misc/Setup" => {
+                    #[allow(non_camel_case_types)]
+                    struct SetupSvc<T: Misc>(pub Arc<T>);
+                    impl<T: Misc> tonic::server::UnaryService<super::SetupRequest>
+                    for SetupSvc<T> {
+                        type Response = super::SetupResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SetupRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Misc>::setup(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = SetupSvc(inner);
+                        let codec = tonic_prost::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
                 _ => {
                     Box::pin(async move {
                         let mut response = http::Response::new(

src/infra/grpc/misc_server.rs

@@ -1,7 +1,7 @@
 #[cfg(feature = "ssr")]
 use tonic::{Request, Response, Status};
 
-use crate::infra::grpc::misc::{HealthCheckRequest, HealthCheckResponse, misc_server::Misc};
+use crate::infra::grpc::misc::{HealthCheckRequest, HealthCheckResponse, SetupRequest, SetupResponse, misc_server::Misc};
 
 
 
@@ -23,4 +23,17 @@ impl Misc for MyMisc {
 
         Ok(Response::new(request))
     }
+
+    async fn setup (
+        &self,
+        request: Request<SetupRequest>,
+    ) -> Result<Response<SetupResponse>, Status> {
+        println!("Got a setup request: {:?}", request);
+
+        let request = SetupResponse {
+            status: true,
+        };
+
+        Ok(Response::new(request))
+    }
 }

src/main.rs

@@ -1,22 +1,17 @@
-
 #[cfg(feature = "ssr")]
 use new_avored::error::Result;
-
+#[cfg(feature = "ssr")]
+use new_avored::infra::app::create_app;
+#[cfg(feature = "ssr")]
+use new_avored::infra::setup::init_app_state;
 
 #[cfg(feature = "ssr")]
 #[tokio::main]
-async fn main() -> Result<()>{
-    use new_avored::infra::setup::init_app_state;
-    use new_avored::infra::app::create_app;
-
+async fn main() -> Result<()> {
     let state = init_app_state().await?;
-    // let conf = get_configuration(None).unwrap();
-    // let addr = &state.leptos_options.site_addr;
-
     let app = create_app(state).await?;
 
-    // run our app with hyper
-    println!("listening on http://{}", 3000);
+    println!("listening on http://0.0.0.0:3000");
     let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
     axum::serve(listener, app).await.unwrap();
 
@@ -26,6 +21,4 @@ async fn main() -> Result<()>{
 #[cfg(not(feature = "ssr"))]
 pub fn main() {
     // no client-side main function
-    // unless we want this to work with e.g., Trunk for pure client-side testing
-    // see lib.rs for hydration function instead
 }

src/pages/home_page.rs

@@ -1,6 +1,38 @@
 use leptos::prelude::*;
 
 
+
+
+#[server]
+pub async fn setup_grpc() -> Result<bool, ServerFnError> {
+    #[cfg(feature = "ssr")]
+    {
+        use crate::infra::grpc::misc::{SetupRequest, misc_client::MiscClient};
+
+        let mut client: MiscClient<tonic::transport::Channel> =
+            MiscClient::connect("http://127.0.0.1:3000")
+                .await
+                .map_err(|e| ServerFnError::new(format!("Connection failed: {}", e)))?;
+
+        let request = tonic::Request::new(SetupRequest {  });
+
+        let response = client
+            .setup(request)
+            .await
+            .map_err(|e| ServerFnError::new(format!("gRPC call failed: {}", e)))?;
+
+        Ok(response.into_inner().status)
+    }
+    #[cfg(not(feature = "ssr"))]
+    {
+        let _ = name;
+        Err(ServerFnError::new(
+            "Server function body should not be called on client",
+        ))
+    }
+}
+
+
 #[server]
 pub async fn health_check_grpc() -> Result<bool, ServerFnError> {
     #[cfg(feature = "ssr")]
@@ -79,6 +111,9 @@ pub fn HomePage() -> impl IntoView {
     let misc_action = ServerAction::<HealthCheckGrpc>::new();
     let misc_result = misc_action.value();
 
+    let setup_action = ServerAction::<SetupGrpc>::new();
+    let setup_result = setup_action.value();
+
     view! {
         <h1>"Welcome to Leptos!"</h1>
         <button on:click=on_click>"Click Me: " {count}</button>
@@ -141,6 +176,30 @@ pub fn HomePage() -> impl IntoView {
             }}
         </p>
 
+        <div>
+            "New Setup Request"
+            <ActionForm action=setup_action>
+
+            <button type="submit">
+                "Call gRPC Setup"
+            </button>
+
+        </ActionForm>
+        </div>
+        <p>
+            {move || match setup_result.get() {
+                None => "".to_string(),
+                Some(Ok(msg)) => {
+                    if msg {
+                        "Setup Passed".to_string()
+                    } else {
+                        "Setup Failed".to_string()
+                    }
+                },
+                Some(Err(err)) => format!("Error: {}", err),
+            }}
+        </p>
+
 
     }
 }