feat: add __rpc

__rpc/dubbo-rust/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "dubbo-rust"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "greeter-server"
+path = "src/greeter/server.rs"
+
+[[bin]]
+name = "greeter-client"
+path = "src/greeter/client.rs"
+
+[dependencies]
+http = "0.2"
+http-body = "0.4.4"
+futures-util = {version = "0.3", default-features = false}
+tokio = { version = "1.0", features = [ "rt-multi-thread", "time", "fs", "macros", "net", "signal"] }
+prost-derive = {version = "0.10", optional = true}
+prost = "0.10.4"
+async-trait = "0.1.56"
+tokio-stream = "0.1"
+
+dubbo = "0.2.0"
+dubbo-config = "0.2.0"
+
+[build-dependencies]
+dubbo-build = "0.2.0"
+
+

__rpc/dubbo-rust/README.md

@@ -0,0 +1,14 @@
+
+Install protoc on macOS:
+```
+PROTOC_ZIP=protoc-3.14.0-osx-x86_64.zip
+curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v3.14.0/$PROTOC_ZIP
+sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
+sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'
+rm -f $PROTOC_ZIP
+```
+
+
+from: http://google.github.io/proto-lens/installing-protoc.html
+
+

__rpc/dubbo-rust/build.rs

@@ -0,0 +1,9 @@
+use std::path::PathBuf;
+
+fn main() {
+    let path = PathBuf::from("./src/greeter");
+    dubbo_build::prost::configure()
+        .output_dir(path)
+        .compile(&["proto/greeter.proto"], &["proto/"])
+        .unwrap();
+}

__rpc/dubbo-rust/dubbo.yaml

@@ -0,0 +1,19 @@
+name: dubbo
+service:
+  org.apache.dubbo.sample.tri.Greeter:
+    version: 1.0.0
+    group: test
+    protocol: triple
+    registry: ''
+    serializer: json
+    protocol_configs:
+      triple:
+        ip: 0.0.0.0
+        port: '8888'
+        name: triple
+protocols:
+  triple:
+    ip: 0.0.0.0
+    port: '8888'
+    name: triple
+

__rpc/dubbo-rust/proto/greeter.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+option java_multiple_files = true;
+
+package org.apache.dubbo.sample.tri;
+
+// The request message containing the user's name.
+message GreeterRequest{
+  string name = 1;
+}
+
+// The response message containing the greetings
+message GreeterReply {
+  string message = 1;
+}
+
+service Greeter{
+  // unary
+  rpc greet(GreeterRequest) returns (GreeterReply);
+}

__rpc/dubbo-rust/src/greeter/client.rs

@@ -0,0 +1,23 @@
+use dubbo::codegen::Request;
+use crate::sample::greeter_client::GreeterClient;
+use crate::sample::GreeterRequest;
+
+mod sample;
+
+#[tokio::main]
+async fn main() {
+    let mut cli = GreeterClient::new().with_uri("http://127.0.0.1:8888".to_string());
+
+    println!("# unary call");
+    let resp = cli
+        .greet(Request::new(GreeterRequest {
+            name: "message from client".to_string(),
+        }))
+        .await;
+    let resp = match resp {
+        Ok(resp) => resp,
+        Err(err) => return println!("{:?}", err),
+    };
+    let (_parts, body) = resp.into_parts();
+    println!("Response: {:?}", body);
+}

__rpc/dubbo-rust/src/greeter/sample.rs

@@ -0,0 +1,169 @@
+/// The request message containing the user's name.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GreeterRequest {
+    #[prost(string, tag="1")]
+    pub name: ::prost::alloc::string::String,
+}
+/// The response message containing the greetings
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GreeterReply {
+    #[prost(string, tag="1")]
+    pub message: ::prost::alloc::string::String,
+}
+/// Generated client implementations.
+pub mod greeter_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use dubbo::codegen::*;
+    #[derive(Debug, Clone, Default)]
+    pub struct GreeterClient {
+        inner: TripleClient,
+        uri: String,
+    }
+    impl GreeterClient {
+        pub fn new() -> Self {
+            Self {
+                inner: TripleClient::new(),
+                uri: "".to_string(),
+            }
+        }
+        pub fn with_uri(mut self, uri: String) -> Self {
+            self.uri = uri.clone();
+            self.inner = self.inner.with_host(uri);
+            self
+        }
+        /// unary
+        pub async fn greet(
+            &mut self,
+            request: Request<super::GreeterRequest>,
+        ) -> Result<Response<super::GreeterReply>, dubbo::status::Status> {
+            let codec = dubbo::codegen::ProstCodec::<
+                super::GreeterRequest,
+                super::GreeterReply,
+            >::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/org.apache.dubbo.sample.tri.Greeter/greet",
+            );
+            self.inner.unary(request, codec, path).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod greeter_server {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use dubbo::codegen::*;
+    ///Generated trait containing gRPC methods that should be implemented for use with GreeterServer.
+    #[async_trait]
+    pub trait Greeter: Send + Sync + 'static {
+        /// unary
+        async fn greet(
+            &self,
+            request: Request<super::GreeterRequest>,
+        ) -> Result<Response<super::GreeterReply>, dubbo::status::Status>;
+    }
+    #[derive(Debug)]
+    pub struct GreeterServer<T: Greeter, I = TripleInvoker> {
+        inner: _Inner<T>,
+        invoker: Option<I>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Greeter, I> GreeterServer<T, I> {
+        pub fn new(inner: T) -> Self {
+            Self {
+                inner: _Inner(Arc::new(inner)),
+                invoker: None,
+            }
+        }
+    }
+    impl<T, I, B> Service<http::Request<B>> for GreeterServer<T, I>
+    where
+        T: Greeter,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+        I: Invoker + Send + 'static,
+    {
+        type Response = http::Response<BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/org.apache.dubbo.sample.tri.Greeter/greet" => {
+                    #[allow(non_camel_case_types)]
+                    struct greetServer<T: Greeter> {
+                        inner: _Inner<T>,
+                    }
+                    impl<T: Greeter> UnarySvc<super::GreeterRequest> for greetServer<T> {
+                        type Response = super::GreeterReply;
+                        type Future = BoxFuture<
+                            Response<Self::Response>,
+                            dubbo::status::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: Request<super::GreeterRequest>,
+                        ) -> Self::Future {
+                            let inner = self.inner.0.clone();
+                            let fut = async move { inner.greet(request).await };
+                            Box::pin(fut)
+                        }
+                    }
+                    let fut = async move {
+                        let mut server = TripleServer::new(
+                            dubbo::codegen::ProstCodec::<
+                                super::GreeterReply,
+                                super::GreeterRequest,
+                            >::default(),
+                        );
+                        let res = server.unary(greetServer { inner }, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", "12")
+                                .header("content-type", "application/grpc")
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    impl<T: Greeter, I: Invoker + Send + 'static> Clone for GreeterServer<T, I> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self { inner, invoker: None }
+        }
+    }
+    impl<T: Greeter> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(self.0.clone())
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    pub fn register_server<T: Greeter>(server: T) {
+        let s = GreeterServer::<_, TripleInvoker>::new(server);
+        dubbo::protocol::triple::TRIPLE_SERVICES
+            .write()
+            .unwrap()
+            .insert(
+                "org.apache.dubbo.sample.tri.Greeter".to_string(),
+                dubbo::utils::boxed_clone::BoxCloneService::new(s),
+            );
+    }
+}

__rpc/dubbo-rust/src/greeter/server.rs

@@ -0,0 +1,46 @@
+use dubbo::codegen::{Request, Response};
+use dubbo::Dubbo;
+use dubbo_config::RootConfig;
+use crate::sample::greeter_server::{Greeter, register_server};
+use crate::sample::{GreeterReply, GreeterRequest};
+
+mod sample;
+
+#[tokio::main]
+async fn main() {
+    register_server(GreeterServerImpl {
+        name: "greeter".to_string(),
+    });
+
+    Dubbo::new()
+        .with_config({
+            let r = RootConfig::new();
+            match r.load() {
+                Ok(config) => config,
+                Err(_err) => panic!("err: {:?}", _err), // response was droped
+            }
+        })
+        .start()
+        .await;
+}
+
+#[allow(dead_code)]
+#[derive(Default, Clone)]
+struct GreeterServerImpl {
+    name: String,
+}
+
+#[async_trait::async_trait]
+impl Greeter for GreeterServerImpl {
+    async fn greet(
+        &self,
+        request: Request<GreeterRequest>,
+    ) -> Result<Response<GreeterReply>, dubbo::status::Status> {
+        println!("GreeterServer::greet {:?}", request.metadata);
+
+        Ok(Response::new(GreeterReply {
+            message: "hello, dubbo-rust".to_string(),
+        }))
+    }
+}
+