initial http server

server/Cargo.toml

@@ -11,8 +11,14 @@ log = "0.4.22"
 prost = "0.13.3"
 rand = "0.8.5"
 tonic = { version = "0.12.3" }
-tokio = { version = "1.40.0", features = ["rt-multi-thread"] }
+tokio = { version = "1.40.0", features = ["rt-multi-thread", "signal"] }
 chrono = "0.4.38"
+actix-web = "4.9.0"
+actix-ws = "0.3.0"
+tokio-util = "0.7.12"
+serde = { version = "1.0.210", features = ["derive"] }
+serde_json = "1.0.132"
+derive_more = { version = "1.0.0", features = ["full"] }
 
 [build-dependencies]
 tonic-build = "0.12.3"

server/src/grpc.rs

@@ -0,0 +1,115 @@
+use std::collections::HashMap;
+use std::error::Error;
+use std::pin::Pin;
+use std::sync::Arc;
+use log::{error, trace};
+use tokio::select;
+use tokio::sync::{mpsc, Mutex};
+use tokio::task::JoinHandle;
+use tokio_util::sync::CancellationToken;
+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 crate::core::telemetry_service_server::{TelemetryService, TelemetryServiceServer};
+use crate::core::{TelemetryDefinitionRequest, TelemetryDefinitionResponse, TelemetryInsertResponse, TelemetryItem, Uuid};
+use crate::TelemetryDefinition;
+
+pub struct CoreTelemetryService {
+    pub map: Arc<Mutex<HashMap<String, TelemetryDefinition>>>,
+    pub cancellation_token: CancellationToken,
+}
+
+#[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 cancel_token = self.cancellation_token.clone();
+        let mut in_stream = request.into_inner();
+        let (tx, rx) = mpsc::channel(128);
+
+        tokio::spawn(async move {
+            loop {
+                select! {
+                    _ = cancel_token.cancelled() => {
+                        break;
+                    },
+                    Some(message) = in_stream.next() => {
+                        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;
+                            }
+                        }
+                    },
+                    else => break,
+                }
+            }
+        });
+
+        Ok(Response::new(Box::pin(ReceiverStream::new(rx))))
+    }
+}
+
+pub fn setup(token: CancellationToken, telemetry_definitions: Arc<Mutex<HashMap<String, TelemetryDefinition>>>) -> Result<JoinHandle<()>, Box<dyn Error>> {
+    let addr = "[::1]:50051".parse()?;
+    Ok(tokio::spawn(async move {
+        let tlm_service = CoreTelemetryService {
+            map: telemetry_definitions,
+            cancellation_token: token.clone()
+        };
+
+        let result = Server::builder()
+            .add_service(TelemetryServiceServer::new(tlm_service))
+            // .serve(addr)
+            .serve_with_shutdown(addr, token.cancelled_owned())
+            .await;
+
+        if let Err(err) = result {
+            error!("gRPC Server Encountered An Error: {err}");
+        }
+    }))
+}

server/src/http.rs

@@ -0,0 +1,54 @@
+use crate::TelemetryDefinition;
+use actix_web::http::header::ContentType;
+use actix_web::http::StatusCode;
+use actix_web::{error, get, web, App, HttpResponse, HttpServer, Responder};
+use derive_more::{Display, Error};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+#[derive(Debug, Display, Error)]
+enum UserError {
+    #[display("Telemetry Not Found: {tlm}")]
+    TlmNotFound { tlm: String },
+}
+
+impl error::ResponseError for UserError {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::build(self.status_code())
+            .insert_header(ContentType::html())
+            .body(self.to_string())
+    }
+    fn status_code(&self) -> StatusCode {
+        match *self {
+            UserError::TlmNotFound { .. } => StatusCode::NOT_FOUND,
+        }
+    }
+}
+
+#[get("/tlm/{name:[\\w\\d/_-]+}")]
+async fn get_tlm_definition(data: web::Data<Arc<Mutex<HashMap<String, TelemetryDefinition>>>>, name: web::Path<String>) -> Result<impl Responder, UserError> {
+    let string = name.to_string();
+    let data = data.lock().await;
+    let tlm_def = data.get(&string);
+
+    if let Some(tlm_def) = tlm_def {
+        Ok(web::Json(tlm_def.clone()))
+    } else {
+        Err(UserError::TlmNotFound { tlm: string })
+    }
+}
+
+pub async fn setup(telemetry_definitions: Arc<Mutex<HashMap<String, TelemetryDefinition>>>) -> Result<(), Box<dyn Error>> {
+    let data = web::Data::new(telemetry_definitions);
+
+    HttpServer::new(move || {
+        App::new()
+            .app_data(data.clone())
+            .service(get_tlm_definition)
+    })
+        .bind("localhost:8080")?
+        .run().await?;
+
+    Ok(())
+}

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 std::fmt::Formatter;
-use log::{trace};
+use std::sync::Arc;
-use tokio::sync::{mpsc, Mutex};
+use tokio::sync::Mutex;
-use tonic::{Request, Response, Status, Streaming};
+use tokio_util::sync::CancellationToken;
-use tonic::codegen::tokio_stream::{Stream, StreamExt};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use tonic::codegen::tokio_stream::wrappers::ReceiverStream;
+use serde::de::Visitor;
-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;
 
-#[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 cancellation_token = CancellationToken::new();
-    let tlm_service = CoreTelemetryService {
+    {
-        map: Mutex::new(HashMap::new()),
+        let cancellation_token = cancellation_token.clone();
-    };
+        tokio::spawn(async move {
+            let _ = tokio::signal::ctrl_c().await;
+            cancellation_token.cancel();
+        });
+    }
 
-    Server::builder()
+    let tlm = Arc::new(Mutex::new(HashMap::new()));
-        .add_service(TelemetryServiceServer::new(tlm_service))
+
-        .serve(addr)
+    let grpc_server = grpc::setup(cancellation_token.clone(), tlm.clone())?;
-        .await?;
+
+    let result = http::setup(tlm).await;
+    cancellation_token.cancel();
+    result?;
+    grpc_server.await?;
 
     Ok(())
 }