Invoke examples (#85)

* Update dependencies

Signed-off-by: Hauke Jung <[email protected]>

* Add grpc invoke examples

Signed-off-by: Hauke Jung <[email protected]>

* Fix fmt errors

Signed-off-by: Hauke Jung <[email protected]>

* Install protoc on github workflow

Signed-off-by: Hauke Jung <[email protected]>

---------

Signed-off-by: Hauke Jung <[email protected]>

Author: hauju

.github/workflows/ci.yml

@@ -34,6 +34,8 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
+    - name: Install Protoc
+      uses: arduino/setup-protoc@v1
     - uses: actions/checkout@v2
     - name: Build
       run: cargo build

Cargo.toml

@@ -2,7 +2,7 @@
 name = "dapr"
 version = "0.10.0"
 authors = ["dapr.io"]
-edition = "2018"
+edition = "2021"
 license-file = "LICENSE"
 repository = "https://github.com/dapr/rust-sdk"
 description = "Rust SDK for dapr"
@@ -11,14 +11,14 @@ keywords = ["microservices", "dapr"]
 
 
 [dependencies]
-tonic = "0.5"
-prost = "0.8"
+tonic = "0.8"
+prost = "0.11"
 bytes = "1"
-prost-types = "0.8"
+prost-types = "0.11"
 async-trait = "0.1"
 
 [build-dependencies]
-tonic-build = "0.5"
+tonic-build = "0.8"
 
 [dev-dependencies]
 tokio = { version = "1", features = ["full"] }
@@ -34,3 +34,19 @@ path = "examples/pubsub/publisher.rs"
 [[example]]
 name = "subscriber"
 path = "examples/pubsub/subscriber.rs"
+
+[[example]]
+name = "invoke-grpc-client"
+path = "examples/invoke/grpc/client.rs"
+
+[[example]]
+name = "invoke-grpc-server"
+path = "examples/invoke/grpc/server.rs"
+
+[[example]]
+name = "invoke-grpc-proxying-client"
+path = "examples/invoke/grpc-proxying/client.rs"
+
+[[example]]
+name = "invoke-grpc-proxying-server"
+path = "examples/invoke/grpc-proxying/server.rs"

README.md

@@ -29,7 +29,7 @@ Dapr is a portable, event-driven, serverless runtime for building distributed ap
 
 ```toml
 [dependencies]
-dapr = "0.5.0"
+dapr = "0.10.0"
 ```
 
 A client can be created as follows:

build.rs

@@ -7,6 +7,7 @@ fn main() -> Result<(), std::io::Error> {
             "dapr/proto/common/v1/common.proto",
             "dapr/proto/runtime/v1/dapr.proto",
             "dapr/proto/runtime/v1/appcallback.proto",
+            "examples/invoke/proto/helloworld.proto",
         ],
         &["."],
     )?;

examples/invoke/grpc-proxying/README.md

@@ -0,0 +1,24 @@
+Before you run the example make sure local redis state store is running by executing:
+```
+docker ps
+```
+
+1. To run the example we need to first build the examples using the following command:
+
+```
+cargo build --examples
+```
+
+2. Run the example with dapr using the following command:
+
+```
+dapr run --app-id=invoke-grpc-server --app-protocol grpc --app-port 50052 -- cargo run --example invoke-grpc-proxying-server
+dapr run --app-id=invoke-grpc-client -- cargo run --example invoke-grpc-proxying-client
+```
+
+If everything went well you should see the following output along with dapr logs:
+```
+Response: HelloReply {
+    message: "Hello Test!",
+}
+```

examples/invoke/grpc-proxying/client.rs

@@ -0,0 +1,32 @@
+use hello_world::{greeter_client::GreeterClient, HelloRequest};
+
+use tonic::metadata::MetadataValue;
+
+pub mod hello_world {
+    tonic::include_proto!("helloworld"); // The string specified here must match the proto package name
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Get the Dapr port for gRPC connection
+    let port: u16 = std::env::var("DAPR_GRPC_PORT").unwrap().parse().unwrap();
+    let address = format!("https://127.0.0.1:{}", port);
+
+    let mut client = GreeterClient::connect(address).await?;
+
+    let request = HelloRequest {
+        name: "Test".to_string(),
+    };
+    let mut request = tonic::Request::new(request);
+    request.metadata_mut().append(
+        "dapr-app-id",
+        MetadataValue::from_static("invoke-grpc-server"),
+    );
+
+    let response = client.say_hello(request).await.unwrap();
+    let hello_reply = response.into_inner();
+
+    println!("Response: {:#?}", hello_reply);
+
+    Ok(())
+}

examples/invoke/grpc-proxying/server.rs

@@ -0,0 +1,44 @@
+use crate::hello_world::greeter_server::{Greeter, GreeterServer};
+use crate::hello_world::{HelloReply, HelloRequest};
+use tonic::{transport::Server, Request, Response, Status};
+
+pub mod hello_world {
+    tonic::include_proto!("helloworld"); // The string specified here must match the proto package name
+}
+
+#[derive(Debug, Default)]
+pub struct GreeterService {}
+
+#[tonic::async_trait]
+impl Greeter for GreeterService {
+    async fn say_hello(
+        &self,
+        request: Request<HelloRequest>,
+    ) -> Result<Response<HelloReply>, Status> {
+        let req = request.into_inner();
+
+        let name = req.name;
+
+        let response = HelloReply {
+            message: format!("Hello {name}!"),
+        };
+
+        Ok(Response::new(response))
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let server_address = "[::]:50052".parse().unwrap();
+
+    let greeter_service = GreeterService::default();
+
+    println!("AppCallback server listening on: {}", server_address);
+    // Create a gRPC server with the callback_service.
+    Server::builder()
+        .add_service(GreeterServer::new(greeter_service))
+        .serve(server_address)
+        .await?;
+
+    Ok(())
+}

examples/invoke/grpc/README.md

@@ -0,0 +1,47 @@
+Before you run the example make sure local redis state store is running by executing:
+```
+docker ps
+```
+
+1. To run the example we need to first build the examples using the following command:
+
+```
+cargo build --examples
+```
+
+2. Run the example with dapr using the following command:
+
+```
+dapr run --app-id=invoke-grpc-server --app-protocol grpc --app-port 50052 -- cargo run --example invoke-grpc-server
+dapr run --app-id=invoke-grpc-client -- cargo run --example invoke-grpc-client
+```
+
+If everything went well you should see the following output along with dapr logs:
+```
+Message: "Hello World!"
+Response: InvokeResponse {
+    data: Some(
+        Any {
+            type_url: "",
+            value: [
+                10,
+                12,
+                72,
+                101,
+                108,
+                108,
+                111,
+                32,
+                87,
+                111,
+                114,
+                108,
+                100,
+                33,
+            ],
+        },
+    ),
+    content_type: "application/json",
+}
+```
+

examples/invoke/grpc/client.rs

@@ -0,0 +1,41 @@
+use hello_world::{HelloReply, HelloRequest};
+use prost::Message;
+
+pub mod hello_world {
+    tonic::include_proto!("helloworld"); // The string specified here must match the proto package name
+}
+
+type DaprClient = dapr::Client<dapr::client::TonicClient>;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Get the Dapr port for gRPC connection
+    let port: u16 = std::env::var("DAPR_GRPC_PORT").unwrap().parse().unwrap();
+    let address = format!("https://127.0.0.1:{}", port);
+
+    let mut client = DaprClient::connect(address).await?;
+
+    let request = HelloRequest {
+        name: "Test".to_string(),
+    };
+    let data = request.encode_to_vec();
+    let data = prost_types::Any {
+        type_url: "".to_string(),
+        value: data,
+    };
+
+    let response = client
+        .invoke_service("invoke-grpc-server", "say_hello", Some(data))
+        .await
+        .unwrap();
+
+    if let Some(any) = &response.data {
+        let data = &any.value;
+        let resp = HelloReply::decode(&data[..]).unwrap();
+        println!("Message: {:#?}", &resp.message);
+    };
+
+    println!("Response: {:#?}", response);
+
+    Ok(())
+}

examples/invoke/grpc/server.rs

@@ -0,0 +1,107 @@
+use dapr::{
+    appcallback::*,
+    dapr::dapr::proto::runtime::v1::app_callback_server::{AppCallback, AppCallbackServer},
+};
+use prost::Message;
+use tonic::{transport::Server, Request, Response, Status};
+
+use hello_world::{HelloReply, HelloRequest};
+
+pub mod hello_world {
+    tonic::include_proto!("helloworld"); // The string specified here must match the proto package name
+}
+
+pub struct AppCallbackService {}
+
+#[tonic::async_trait]
+impl AppCallback for AppCallbackService {
+    /// Invokes service method with InvokeRequest.
+    async fn on_invoke(
+        &self,
+        request: Request<InvokeRequest>,
+    ) -> Result<Response<InvokeResponse>, Status> {
+        let r = request.into_inner();
+
+        let method = &r.method;
+        println!("Method: {method}");
+        let data = &r.data;
+
+        if let Some(any) = data {
+            let data = &any.value;
+            let resp = HelloRequest::decode(&data[..]).unwrap();
+            println!("Name: {:#?}", &resp.name);
+
+            let response = HelloReply {
+                message: "Hello World!".to_string(),
+            };
+            let data = response.encode_to_vec();
+
+            let data = prost_types::Any {
+                type_url: "".to_string(),
+                value: data,
+            };
+
+            let invoke_response = InvokeResponse {
+                content_type: "application/json".to_string(),
+                data: Some(data),
+            };
+
+            return Ok(Response::new(invoke_response));
+        };
+
+        Ok(Response::new(InvokeResponse::default()))
+    }
+
+    /// Lists all topics subscribed by this app.
+    ///
+    /// NOTE: Dapr runtime will call this method to get
+    /// the list of topics the app wants to subscribe to.
+    /// In this example, the app is subscribing to topic `A`.
+    async fn list_topic_subscriptions(
+        &self,
+        _request: Request<()>,
+    ) -> Result<Response<ListTopicSubscriptionsResponse>, Status> {
+        let list_subscriptions = ListTopicSubscriptionsResponse::default();
+        Ok(Response::new(list_subscriptions))
+    }
+
+    /// Subscribes events from Pubsub.
+    async fn on_topic_event(
+        &self,
+        _request: Request<TopicEventRequest>,
+    ) -> Result<Response<TopicEventResponse>, Status> {
+        Ok(Response::new(TopicEventResponse::default()))
+    }
+
+    /// Lists all input bindings subscribed by this app.
+    async fn list_input_bindings(
+        &self,
+        _request: Request<()>,
+    ) -> Result<Response<ListInputBindingsResponse>, Status> {
+        Ok(Response::new(ListInputBindingsResponse::default()))
+    }
+
+    /// Listens events from the input bindings.
+    async fn on_binding_event(
+        &self,
+        _request: Request<BindingEventRequest>,
+    ) -> Result<Response<BindingEventResponse>, Status> {
+        Ok(Response::new(BindingEventResponse::default()))
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let server_address = "[::]:50052".parse().unwrap();
+
+    let callback_service = AppCallbackService {};
+
+    println!("AppCallback server listening on: {}", server_address);
+    // Create a gRPC server with the callback_service.
+    Server::builder()
+        .add_service(AppCallbackServer::new(callback_service))
+        .serve(server_address)
+        .await?;
+
+    Ok(())
+}