init

server/src/lib.rs

@@ -0,0 +1,74 @@
+mod uuid;
+
+pub mod core {
+    tonic::include_proto!("core");
+}
+
+use std::error::Error;
+use std::pin::Pin;
+use log::{trace};
+use tokio::sync::mpsc;
+use tonic::{Request, Response, Status, Streaming};
+use tonic::codegen::tokio_stream::{Stream, StreamExt};
+use tonic::codegen::tokio_stream::wrappers::ReceiverStream;
+use tonic::transport::Server;
+use core::telemetry_service_server::TelemetryService;
+use crate::core::{TelemetryDefinitionRequest, TelemetryDefinitionResponse, TelemetryInsertResponse, TelemetryItem, Uuid};
+use crate::core::telemetry_service_server::TelemetryServiceServer;
+
+#[derive(Debug, Default)]
+pub struct CoreTelemetryService {}
+
+#[tonic::async_trait]
+impl TelemetryService for CoreTelemetryService {
+    async fn new_telemetry(&self, request: Request<TelemetryDefinitionRequest>) -> Result<Response<TelemetryDefinitionResponse>, Status> {
+        trace!("TelemetryService::new_telemetry {:?}", request);
+
+        let reply = TelemetryDefinitionResponse {
+            uuid: Some(Uuid::random()),
+        };
+
+        Ok(Response::new(reply))
+    }
+
+    type InsertTelemetryStream = Pin<Box<dyn Stream<Item = Result<TelemetryInsertResponse, Status>> + Send>>;
+
+    async fn insert_telemetry(&self, request: Request<Streaming<TelemetryItem>>) -> Result<Response<Self::InsertTelemetryStream>, Status> {
+        trace!("TelemetryService::insert_telemetry {:?}", request);
+
+        let mut in_stream = request.into_inner();
+        let (tx, rx) = mpsc::channel(128);
+
+        tokio::spawn(async move {
+            while let Some(message) = in_stream.next().await {
+                match message {
+                    Ok(tlm_item) => {
+                        trace!("tlm_item {:?}", tlm_item);
+                        tx
+                            .send(Ok(TelemetryInsertResponse {}))
+                            .await
+                            .expect("working rx");
+                    }
+                    Err(err) => {
+                        let _ = tx.send(Err(err)).await;
+                    }
+                }
+            }
+        });
+
+        Ok(Response::new(Box::pin(ReceiverStream::new(rx))))
+    }
+}
+
+pub async fn setup() -> Result<(), Box<dyn Error>> {
+    let addr = "[::1]:50051".parse()?;
+    let tlm_service = CoreTelemetryService::default();
+
+    Server::builder()
+        .add_service(TelemetryServiceServer::new(tlm_service))
+        .serve(addr)
+        .await?;
+
+    Ok(())
+}
+