initial http server

server/src/lib.rs

@@ -1,108 +1,73 @@
 mod uuid;
+mod grpc;
+mod http;
 
 pub mod core {
     tonic::include_proto!("core");
 }
 
 use std::collections::HashMap;
+use crate::core::TelemetryDataType;
 use std::error::Error;
-use std::pin::Pin;
-use log::{trace};
-use tokio::sync::{mpsc, Mutex};
-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::{TelemetryDataType, TelemetryDefinitionRequest, TelemetryDefinitionResponse, TelemetryInsertResponse, TelemetryItem, Uuid};
-use crate::core::telemetry_service_server::TelemetryServiceServer;
+use std::fmt::Formatter;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use tokio_util::sync::CancellationToken;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::de::Visitor;
 
-#[derive(Debug)]
+fn tlm_data_type_serialzier<S>(tlm_data_type: &TelemetryDataType, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+    serializer.serialize_str(tlm_data_type.as_str_name())
+}
+
+struct TlmDataTypeVisitor;
+
+impl<'de> Visitor<'de> for TlmDataTypeVisitor {
+    type Value = TelemetryDataType;
+
+    fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+        formatter.write_str("A &str")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        TelemetryDataType::from_str_name(v).ok_or(E::custom("Invalid TelemetryDataType"))
+    }
+}
+
+fn tlm_data_type_deserialzier<'de, D>(deserializer: D) -> Result<TelemetryDataType, D::Error> where D: Deserializer<'de> {
+    deserializer.deserialize_str(TlmDataTypeVisitor)
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
 struct TelemetryDefinition {
     uuid: Vec<u8>,
-    // name: String,
+    name: String,
+    #[serde(serialize_with = "tlm_data_type_serialzier")]
+    #[serde(deserialize_with = "tlm_data_type_deserialzier")]
     data_type: TelemetryDataType,
 }
 
-pub struct CoreTelemetryService {
-    map: Mutex<HashMap<String, TelemetryDefinition>>
-}
-
-#[tonic::async_trait]
-impl TelemetryService for CoreTelemetryService {
-    async fn new_telemetry(&self, request: Request<TelemetryDefinitionRequest>) -> Result<Response<TelemetryDefinitionResponse>, Status> {
-        trace!("TelemetryService::new_telemetry");
-
-        let telemetry_definition_request = request.into_inner();
-
-        let uuid = {
-            let mut lock = self.map.lock().await;
-            if let Some(definition) = lock.get(&telemetry_definition_request.name) {
-                trace!("Telemetry Definition Found {:?}", definition);
-                if definition.data_type != telemetry_definition_request.data_type() {
-                    return Err(Status::already_exists("A telemetry item of the same name already exists"));
-                }
-                definition.uuid.clone()
-            } else {
-                trace!("Adding New Telemetry Definition {:?}", telemetry_definition_request);
-                let uuid = Uuid::random().value;
-                lock.insert(telemetry_definition_request.name.clone(), TelemetryDefinition {
-                    uuid: uuid.clone(),
-                    // name: telemetry_definition_request.name.clone(),
-                    data_type: telemetry_definition_request.data_type().clone(),
-                });
-                uuid
-            }
-        };
-
-        let reply = TelemetryDefinitionResponse {
-            uuid: Some(Uuid {
-                value: uuid
-            }),
-        };
-
-        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");
-
-        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 {
-        map: Mutex::new(HashMap::new()),
-    };
+    let cancellation_token = CancellationToken::new();
+    {
+        let cancellation_token = cancellation_token.clone();
+        tokio::spawn(async move {
+            let _ = tokio::signal::ctrl_c().await;
+            cancellation_token.cancel();
+        });
+    }
 
-    Server::builder()
-        .add_service(TelemetryServiceServer::new(tlm_service))
-        .serve(addr)
-        .await?;
+    let tlm = Arc::new(Mutex::new(HashMap::new()));
+
+    let grpc_server = grpc::setup(cancellation_token.clone(), tlm.clone())?;
+
+    let result = http::setup(tlm).await;
+    cancellation_token.cancel();
+    result?;
+    grpc_server.await?;
 
     Ok(())
 }