chore: Reorganize examples and interop crates (#180)

* chore: Reorganize examples and interop crates

* fix interop tests

examples/src/routeguide/server.rs

@@ -0,0 +1,217 @@
+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 tokio::sync::mpsc;
+use tonic::transport::Server;
+use tonic::{Request, Response, Status};
+
+pub mod routeguide {
+    tonic::include_proto!("routeguide");
+}
+
+use routeguide::{routeguide_server, Feature, Point, Rectangle, RouteNote, RouteSummary};
+
+#[derive(Debug)]
+pub struct RouteGuide {
+    features: Arc<Vec<Feature>>,
+}
+
+#[tonic::async_trait]
+impl routeguide_server::RouteGuide for RouteGuide {
+    async fn get_feature(&self, request: Request<Point>) -> Result<Response<Feature>, Status> {
+        println!("GetFeature = {:?}", request);
+
+        for feature in &self.features[..] {
+            if feature.location.as_ref() == Some(request.get_ref()) {
+                return Ok(Response::new(feature.clone()));
+            }
+        }
+
+        let response = Response::new(Feature {
+            name: "".to_string(),
+            location: None,
+        });
+
+        Ok(response)
+    }
+
+    type ListFeaturesStream = mpsc::Receiver<Result<Feature, Status>>;
+
+    async fn list_features(
+        &self,
+        request: Request<Rectangle>,
+    ) -> Result<Response<Self::ListFeaturesStream>, Status> {
+        println!("ListFeatures = {:?}", request);
+
+        let (mut tx, rx) = mpsc::channel(4);
+        let features = self.features.clone();
+
+        tokio::spawn(async move {
+            for feature in &features[..] {
+                if in_range(feature.location.as_ref().unwrap(), request.get_ref()) {
+                    println!("  => send {:?}", feature);
+                    tx.send(Ok(feature.clone())).await.unwrap();
+                }
+            }
+
+            println!(" /// done sending");
+        });
+
+        Ok(Response::new(rx))
+    }
+
+    async fn record_route(
+        &self,
+        request: Request<tonic::Streaming<Point>>,
+    ) -> Result<Response<RouteSummary>, Status> {
+        println!("RecordRoute");
+
+        let stream = request.into_inner();
+
+        // Pin the inbound stream to the stack so that we can call next on it
+        futures::pin_mut!(stream);
+
+        let mut summary = RouteSummary::default();
+        let mut last_point = None;
+        let now = Instant::now();
+
+        while let Some(point) = stream.next().await {
+            let point = point?;
+
+            println!("  ==> Point = {:?}", point);
+
+            // Increment the point count
+            summary.point_count += 1;
+
+            // Find features
+            for feature in &self.features[..] {
+                if feature.location.as_ref() == Some(&point) {
+                    summary.feature_count += 1;
+                }
+            }
+
+            // Calculate the distance
+            if let Some(ref last_point) = last_point {
+                summary.distance += calc_distance(last_point, &point);
+            }
+
+            last_point = Some(point);
+        }
+
+        summary.elapsed_time = now.elapsed().as_secs() as i32;
+
+        Ok(Response::new(summary))
+    }
+
+    type RouteChatStream =
+        Pin<Box<dyn Stream<Item = Result<RouteNote, Status>> + Send + Sync + 'static>>;
+
+    async fn route_chat(
+        &self,
+        request: Request<tonic::Streaming<RouteNote>>,
+    ) -> Result<Response<Self::RouteChatStream>, Status> {
+        println!("RouteChat");
+
+        let mut notes = HashMap::new();
+        let stream = request.into_inner();
+
+        let output = async_stream::try_stream! {
+            futures::pin_mut!(stream);
+
+            while let Some(note) = stream.next().await {
+                let note = note?;
+
+                let location = note.location.clone().unwrap();
+
+                let location_notes = notes.entry(location).or_insert(vec![]);
+                location_notes.push(note);
+
+                for note in location_notes {
+                    yield note.clone();
+                }
+            }
+        };
+
+        Ok(Response::new(Box::pin(output)
+            as Pin<
+                Box<dyn Stream<Item = Result<RouteNote, Status>> + Send + Sync + 'static>,
+            >))
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let addr = "[::1]:10000".parse().unwrap();
+
+    println!("Listening on: {}", addr);
+
+    let route_guide = RouteGuide {
+        features: Arc::new(data::load()),
+    };
+
+    let svc = routeguide_server::RouteGuideServer::new(route_guide);
+
+    Server::builder().add_service(svc).serve(addr).await?;
+
+    Ok(())
+}
+
+// Implement hash for Point
+impl Hash for Point {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        self.latitude.hash(state);
+        self.longitude.hash(state);
+    }
+}
+
+impl Eq for Point {}
+
+fn in_range(point: &Point, rect: &Rectangle) -> bool {
+    use std::cmp;
+
+    let lo = rect.lo.as_ref().unwrap();
+    let hi = rect.hi.as_ref().unwrap();
+
+    let left = cmp::min(lo.longitude, hi.longitude);
+    let right = cmp::max(lo.longitude, hi.longitude);
+    let top = cmp::max(lo.latitude, hi.latitude);
+    let bottom = cmp::min(lo.latitude, hi.latitude);
+
+    point.longitude >= left
+        && point.longitude <= right
+        && point.latitude >= bottom
+        && point.latitude <= top
+}
+
+/// Calculates the distance between two points using the "haversine" formula.
+/// This code was taken from http://www.movable-type.co.uk/scripts/latlong.html.
+fn calc_distance(p1: &Point, p2: &Point) -> i32 {
+    const CORD_FACTOR: f64 = 1e7;
+    const R: f64 = 6371000.0; // meters
+
+    let lat1 = p1.latitude as f64 / CORD_FACTOR;
+    let lat2 = p2.latitude as f64 / CORD_FACTOR;
+    let lng1 = p1.longitude as f64 / CORD_FACTOR;
+    let lng2 = p2.longitude as f64 / CORD_FACTOR;
+
+    let lat_rad1 = lat1.to_radians();
+    let lat_rad2 = lat2.to_radians();
+
+    let delta_lat = (lat2 - lat1).to_radians();
+    let delta_lng = (lng2 - lng1).to_radians();
+
+    let a = (delta_lat / 2f64).sin() * (delta_lat / 2f64).sin()
+        + (lat_rad1).cos() * (lat_rad2).cos() * (delta_lng / 2f64).sin() * (delta_lng / 2f64).sin();
+
+    let c = 2f64 * a.sqrt().atan2((1f64 - a).sqrt());
+
+    (R * c) as i32
+}