chore(example): update guides to 0.1-beta.1 (#198)

* update routeguide

* update helloworld

* depend on tonic beta.1

* Apply suggestions from code review

Co-Authored-By: Lucio Franco <[email protected]>

Co-authored-by: Lucio Franco <[email protected]>

examples/src/helloworld/client.rs

@@ -1,9 +1,10 @@
+use hello_world::greeter_client::GreeterClient;
+use hello_world::HelloRequest;
+
 pub mod hello_world {
     tonic::include_proto!("helloworld");
 }
 
-use hello_world::{greeter_client::GreeterClient, HelloRequest};
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut client = GreeterClient::connect("http://[::1]:50051").await?;

examples/src/helloworld/server.rs

@@ -1,14 +1,12 @@
 use tonic::{transport::Server, Request, Response, Status};
 
+use hello_world::greeter_server::{Greeter, GreeterServer};
+use hello_world::{HelloReply, HelloRequest};
+
 pub mod hello_world {
     tonic::include_proto!("helloworld");
 }
 
-use hello_world::{
-    greeter_server::{Greeter, GreeterServer},
-    HelloReply, HelloRequest,
-};
-
 #[derive(Default)]
 pub struct MyGreeter {}
 
@@ -32,6 +30,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let addr = "[::1]:50051".parse().unwrap();
     let greeter = MyGreeter::default();
 
+    println!("GreeterServer listening on {}", addr);
+
     Server::builder()
         .add_service(GreeterServer::new(greeter))
         .serve(addr)

examples/src/routeguide/client.rs

@@ -1,19 +1,20 @@
+use std::error::Error;
+use std::time::Duration;
+
 use futures::stream;
 use rand::rngs::ThreadRng;
 use rand::Rng;
-use route_guide::{Point, Rectangle, RouteNote};
-use std::error::Error;
-use std::time::Duration;
-use tokio::time::Instant;
+use tokio::time;
 use tonic::transport::Channel;
 use tonic::Request;
 
-pub mod route_guide {
+use routeguide::route_guide_client::RouteGuideClient;
+use routeguide::{Point, Rectangle, RouteNote};
+
+pub mod routeguide {
     tonic::include_proto!("routeguide");
 }
 
-use route_guide::route_guide_client::RouteGuideClient;
-
 async fn print_features(client: &mut RouteGuideClient<Channel>) -> Result<(), Box<dyn Error>> {
     let rectangle = Rectangle {
         lo: Some(Point {
@@ -59,10 +60,10 @@ async fn run_record_route(client: &mut RouteGuideClient<Channel>) -> Result<(),
 }
 
 async fn run_route_chat(client: &mut RouteGuideClient<Channel>) -> Result<(), Box<dyn Error>> {
-    let start = Instant::now();
+    let start = time::Instant::now();
 
     let outbound = async_stream::stream! {
-        let mut interval = tokio::time::interval(Duration::from_secs(1));
+        let mut interval = time::interval(Duration::from_secs(1));
 
         while let time = interval.tick().await {
             let elapsed = time.duration_since(start);
@@ -78,8 +79,7 @@ async fn run_route_chat(client: &mut RouteGuideClient<Channel>) -> Result<(), Bo
         }
     };
 
-    let request = Request::new(outbound);
-    let response = client.route_chat(request).await?;
+    let response = client.route_chat(Request::new(outbound)).await?;
     let mut inbound = response.into_inner();
 
     while let Some(note) = inbound.message().await? {

examples/src/routeguide/data.rs

@@ -15,8 +15,7 @@ struct Location {
 
 #[allow(dead_code)]
 pub fn load() -> Vec<crate::routeguide::Feature> {
-    let file =
-        File::open("tonic-examples/data/route_guide_db.json").expect("failed to open data file");
+    let file = File::open("examples/data/route_guide_db.json").expect("failed to open data file");
 
     let decoded: Vec<Feature> =
         serde_json::from_reader(&file).expect("failed to deserialize features");

examples/src/routeguide/server.rs

@@ -1,28 +1,30 @@
-mod data;
-
-use futures::{Stream, StreamExt};
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Instant;
+
+use futures::{Stream, StreamExt};
 use tokio::sync::mpsc;
 use tonic::transport::Server;
 use tonic::{Request, Response, Status};
 
+use routeguide::route_guide_server::{RouteGuide, RouteGuideServer};
+use routeguide::{Feature, Point, Rectangle, RouteNote, RouteSummary};
+
 pub mod routeguide {
     tonic::include_proto!("routeguide");
 }
 
-use routeguide::{route_guide_server, Feature, Point, Rectangle, RouteNote, RouteSummary};
+mod data;
 
 #[derive(Debug)]
-pub struct RouteGuide {
+pub struct RouteGuideService {
     features: Arc<Vec<Feature>>,
 }
 
 #[tonic::async_trait]
-impl route_guide_server::RouteGuide for RouteGuide {
+impl RouteGuide for RouteGuideService {
     async fn get_feature(&self, request: Request<Point>) -> Result<Response<Feature>, Status> {
         println!("GetFeature = {:?}", request);
 
@@ -32,12 +34,7 @@ impl route_guide_server::RouteGuide for RouteGuide {
             }
         }
 
-        let response = Response::new(Feature {
-            name: "".to_string(),
-            location: None,
-        });
-
-        Ok(response)
+        Ok(Response::new(Feature::default()))
     }
 
     type ListFeaturesStream = mpsc::Receiver<Result<Feature, Status>>;
@@ -148,13 +145,13 @@ impl route_guide_server::RouteGuide for RouteGuide {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let addr = "[::1]:10000".parse().unwrap();
 
-    println!("Listening on: {}", addr);
+    println!("RouteGuideServer listening on: {}", addr);
 
-    let route_guide = RouteGuide {
+    let route_guide = RouteGuideService {
         features: Arc::new(data::load()),
     };
 
-    let svc = route_guide_server::RouteGuideServer::new(route_guide);
+    let svc = RouteGuideServer::new(route_guide);
 
     Server::builder().add_service(svc).serve(addr).await?;