sergeysav/telemetry_visualization
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial http server

Browse Source
This commit is contained in:
Sergey Savelyev
2024-10-19 18:22:04 -07:00
parent c9bf33ab6c
commit 4d5b525288
5 changed files with 997 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
server/src/grpc.rs Normal file
View File

@@ -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}");
}
}))
}

54
server/src/http.rs Normal file
View File

@@ -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(())
}

143
server/src/lib.rs
View File

@@ -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(())
}