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

fixes formatting and lints

Browse Source
This commit is contained in:
Sergey Savelyev
2024-12-27 11:05:47 -05:00
parent 147d1abaf8
commit 12f27bad69
11 changed files with 281 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
server/src/grpc.rs
View File

@@ -1,20 +1,23 @@
use crate::core::telemetry_service_server::{TelemetryService, TelemetryServiceServer};
use crate::core::telemetry_value::Value;
use crate::core::{
TelemetryDataType, TelemetryDefinitionRequest, TelemetryDefinitionResponse,
TelemetryInsertResponse, TelemetryItem, TelemetryValue, Uuid,
};
use crate::telemetry::{TelemetryDataItem, TelemetryDataValue, TelemetryManagementService};
use chrono::{DateTime, SecondsFormat};
use log::{error, trace};
use std::error::Error;
use std::pin::Pin;
use std::sync::Arc;
use chrono::{DateTime, SecondsFormat};
use log::{error, trace};
use tokio::select;
use tokio::sync::mpsc;
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::codegen::tokio_stream::{Stream, StreamExt};
use tonic::transport::Server;
use crate::core::telemetry_service_server::{TelemetryService, TelemetryServiceServer};
use crate::core::{TelemetryDataType, TelemetryDefinitionRequest, TelemetryDefinitionResponse, TelemetryInsertResponse, TelemetryItem, TelemetryValue, Uuid};
use crate::core::telemetry_value::Value;
use crate::telemetry::{TelemetryDataItem, TelemetryDataValue, TelemetryManagementService};
use tonic::{Request, Response, Status, Streaming};
pub struct CoreTelemetryService {
pub tlm_management: Arc<TelemetryManagementService>,
@@ -23,24 +26,29 @@ pub struct CoreTelemetryService {
#[tonic::async_trait]
impl TelemetryService for CoreTelemetryService {
async fn new_telemetry(&self, request: Request<TelemetryDefinitionRequest>) -> Result<Response<TelemetryDefinitionResponse>, Status> {
async fn new_telemetry(
&self,
request: Request<TelemetryDefinitionRequest>,
) -> Result<Response<TelemetryDefinitionResponse>, Status> {
trace!("CoreTelemetryService::new_telemetry");
self.tlm_management.register(request.into_inner()).await
.map(|uuid|
self.tlm_management
.register(request.into_inner())
.await
.map(|uuid| {
Response::new(TelemetryDefinitionResponse {
uuid: Some(Uuid {
value: uuid
}),
uuid: Some(Uuid { value: uuid }),
})
)
.map_err(|err|
Status::already_exists(err.to_string())
)
})
.map_err(|err| Status::already_exists(err.to_string()))
}
type InsertTelemetryStream = Pin<Box<dyn Stream<Item = Result<TelemetryInsertResponse, Status>> + Send>>;
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> {
async fn insert_telemetry(
&self,
request: Request<Streaming<TelemetryItem>>,
) -> Result<Response<Self::InsertTelemetryStream>, Status> {
trace!("CoreTelemetryService::insert_telemetry");
let cancel_token = self.cancellation_token.clone();
@@ -77,7 +85,10 @@ impl TelemetryService for CoreTelemetryService {
}
impl CoreTelemetryService {
async fn handle_new_tlm_item(tlm_management: &Arc<TelemetryManagementService>, tlm_item: &TelemetryItem) -> Result<TelemetryInsertResponse, Status> {
async fn handle_new_tlm_item(
tlm_management: &Arc<TelemetryManagementService>,
tlm_item: &TelemetryItem,
) -> Result<TelemetryInsertResponse, Status> {
trace!("CoreTelemetryService::handle_new_tlm_item {:?}", tlm_item);
let Some(ref uuid) = tlm_item.uuid else {
return Err(Status::failed_precondition("UUID Missing"));
@@ -102,7 +113,8 @@ impl CoreTelemetryService {
return Err(Status::failed_precondition("Data Type Mismatch"));
};
let Some(timestamp) = DateTime::from_timestamp(timestamp.secs, timestamp.nanos as u32) else {
let Some(timestamp) = DateTime::from_timestamp(timestamp.secs, timestamp.nanos as u32)
else {
return Err(Status::invalid_argument("Failed to construct UTC DateTime"));
};
@@ -111,19 +123,22 @@ impl CoreTelemetryService {
Value::Float32(x) => TelemetryDataValue::Float32(x),
Value::Float64(x) => TelemetryDataValue::Float64(x),
},
timestamp: timestamp.to_rfc3339_opts(SecondsFormat::Millis, true)
timestamp: timestamp.to_rfc3339_opts(SecondsFormat::Millis, true),
}));
Ok(TelemetryInsertResponse {})
}
}
pub fn setup(token: CancellationToken, telemetry_management_service: Arc<TelemetryManagementService>) -> Result<JoinHandle<()>, Box<dyn Error>> {
pub fn setup(
token: CancellationToken,
telemetry_management_service: Arc<TelemetryManagementService>,
) -> Result<JoinHandle<()>, Box<dyn Error>> {
let addr = "[::1]:50051".parse()?;
Ok(tokio::spawn(async move {
let tlm_service = CoreTelemetryService {
tlm_management: telemetry_management_service,
cancellation_token: token.clone()
cancellation_token: token.clone(),
};
trace!("Starting gRPC Server");

51
server/src/http.rs
View File

@@ -1,15 +1,15 @@
use crate::telemetry::{TelemetryDataItem, TelemetryManagementService};
use actix_web::http::header::ContentType;
use actix_web::http::StatusCode;
use actix_web::{rt, error, get, web, App, HttpRequest, HttpResponse, HttpServer, Responder};
use derive_more::{Display, Error};
use std::sync::Arc;
use actix_web::{error, get, rt, web, App, HttpRequest, HttpResponse, HttpServer, Responder};
use actix_ws::AggregatedMessage;
use derive_more::{Display, Error};
use log::{error, trace};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::select;
use tokio_util::sync::CancellationToken;
use tonic::codegen::tokio_stream::StreamExt;
use crate::telemetry::{TelemetryDataItem, TelemetryManagementService};
#[derive(Debug, Display, Error)]
enum UserError {
@@ -18,35 +18,36 @@ enum UserError {
}
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,
}
}
fn error_response(&self) -> HttpResponse {
HttpResponse::build(self.status_code())
.insert_header(ContentType::html())
.body(self.to_string())
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
enum WebsocketRequest {
RegisterTlmListener {
uuid: String
}
RegisterTlmListener { uuid: String },
}
#[derive(Debug, Clone, Serialize, Deserialize)]
enum WebsocketResponse {
TlmValue {
uuid: String,
value: Option<TelemetryDataItem>
}
value: Option<TelemetryDataItem>,
},
}
#[get("/tlm/{name:[\\w\\d/_-]+}")]
async fn get_tlm_definition(data: web::Data<Arc<TelemetryManagementService>>, name: web::Path<String>) -> Result<impl Responder, UserError> {
async fn get_tlm_definition(
data: web::Data<Arc<TelemetryManagementService>>,
name: web::Path<String>,
) -> Result<impl Responder, UserError> {
let string = name.to_string();
trace!("get_tlm_definition {}", string);
let Some(data) = data.get_by_name(&string).await else {
@@ -56,7 +57,12 @@ async fn get_tlm_definition(data: web::Data<Arc<TelemetryManagementService>>, na
Ok(web::Json(data.definition.clone()))
}
async fn websocket_connect(req: HttpRequest, stream: web::Payload, data: web::Data<Arc<TelemetryManagementService>>, cancel_token: web::Data<CancellationToken>) -> Result<HttpResponse, actix_web::Error> {
async fn websocket_connect(
req: HttpRequest,
stream: web::Payload,
data: web::Data<Arc<TelemetryManagementService>>,
cancel_token: web::Data<CancellationToken>,
) -> Result<HttpResponse, actix_web::Error> {
trace!("websocket_connect");
let (res, mut session, stream) = actix_ws::handle(&req, stream)?;
@@ -157,11 +163,13 @@ async fn websocket_connect(req: HttpRequest, stream: web::Payload, data: web::Da
}
fn setup_api(cfg: &mut web::ServiceConfig) {
cfg
.service(get_tlm_definition);
cfg.service(get_tlm_definition);
}
pub async fn setup(cancellation_token: CancellationToken, telemetry_definitions: Arc<TelemetryManagementService>) -> Result<(), Box<dyn Error>> {
pub async fn setup(
cancellation_token: CancellationToken,
telemetry_definitions: Arc<TelemetryManagementService>,
) -> Result<(), Box<dyn Error>> {
let data = web::Data::new(telemetry_definitions);
let cancel_token = web::Data::new(cancellation_token);
@@ -173,8 +181,9 @@ pub async fn setup(cancellation_token: CancellationToken, telemetry_definitions:
.route("/ws", web::get().to(websocket_connect))
.service(web::scope("/api").configure(setup_api))
})
.bind("localhost:8080")?
.run().await?;
.bind("localhost:8080")?
.run()
.await?;
Ok(())
}

3
server/src/lib.rs
View File

@@ -1,7 +1,7 @@
mod uuid;
mod grpc;
mod http;
mod telemetry;
mod uuid;
pub mod core {
tonic::include_proto!("core");
@@ -33,4 +33,3 @@ pub async fn setup() -> Result<(), Box<dyn Error>> {
Ok(())
}

5
server/src/main.rs
View File

@@ -5,9 +5,8 @@ use std::str::FromStr;
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let log_file = env::var("LOG_FILE");
let log_level = match env::var("LOG_LEVEL") {
Ok(log_level) => log::LevelFilter::from_str(&log_level)
.unwrap_or(log::LevelFilter::Info),
Err(_) => log::LevelFilter::Info
Ok(log_level) => log::LevelFilter::from_str(&log_level).unwrap_or(log::LevelFilter::Info),
Err(_) => log::LevelFilter::Info,
};
let mut log_config = fern::Dispatch::new()

52
server/src/telemetry.rs
View File

@@ -1,14 +1,20 @@
use crate::core::{TelemetryDataType, TelemetryDefinitionRequest, Uuid};
use log::trace;
use serde::de::Visitor;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::collections::HashMap;
use std::error::Error;
use std::fmt::Formatter;
use std::sync::Arc;
use log::trace;
use serde::de::Visitor;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use tokio::sync::Mutex;
use crate::core::{TelemetryDataType, TelemetryDefinitionRequest, Uuid};
fn tlm_data_type_serialzier<S>(tlm_data_type: &TelemetryDataType, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
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())
}
@@ -29,7 +35,10 @@ impl Visitor<'_> for TlmDataTypeVisitor {
}
}
fn tlm_data_type_deserialzier<'de, D>(deserializer: D) -> Result<TelemetryDataType, D::Error> where D: Deserializer<'de> {
fn tlm_data_type_deserialzier<'de, D>(deserializer: D) -> Result<TelemetryDataType, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_str(TlmDataTypeVisitor)
}
@@ -51,7 +60,7 @@ pub enum TelemetryDataValue {
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TelemetryDataItem {
pub value: TelemetryDataValue,
pub timestamp: String
pub timestamp: String,
}
#[derive(Clone)]
@@ -73,12 +82,15 @@ impl TelemetryManagementService {
}
}
pub async fn register(&self, telemetry_definition_request: TelemetryDefinitionRequest) -> Result<String, Box<dyn Error>> {
pub async fn register(
&self,
telemetry_definition_request: TelemetryDefinitionRequest,
) -> Result<String, Box<dyn Error>> {
let mut lock = self.uuid_mapping.lock().await;
if let Some(uuid) = lock.get(&telemetry_definition_request.name) {
trace!("Telemetry Definition Found {:?}", uuid);
let tlm_lock = self.tlm_mapping.lock().await;
if let Some(TelemetryData { definition, ..}) = tlm_lock.get(uuid) {
if let Some(TelemetryData { definition, .. }) = tlm_lock.get(uuid) {
if definition.data_type != telemetry_definition_request.data_type() {
return Err("A telemetry item of the same name already exists".into());
}
@@ -87,18 +99,24 @@ impl TelemetryManagementService {
Err("Could not find Telemetry Data".into())
}
} else {
trace!("Adding New Telemetry Definition {:?}", telemetry_definition_request);
trace!(
"Adding New Telemetry Definition {:?}",
telemetry_definition_request
);
let mut tlm_lock = self.tlm_mapping.lock().await;
let uuid = Uuid::random().value;
lock.insert(telemetry_definition_request.name.clone(), uuid.clone());
tlm_lock.insert(uuid.clone(), TelemetryData {
definition: TelemetryDefinition {
uuid: uuid.clone(),
name: telemetry_definition_request.name.clone(),
data_type: telemetry_definition_request.data_type(),
tlm_lock.insert(
uuid.clone(),
TelemetryData {
definition: TelemetryDefinition {
uuid: uuid.clone(),
name: telemetry_definition_request.name.clone(),
data_type: telemetry_definition_request.data_type(),
},
data: tokio::sync::watch::channel(None).0,
},
data: tokio::sync::watch::channel(None).0
});
);
Ok(uuid)
}
}

4
server/src/uuid.rs
View File

@@ -1,9 +1,9 @@
use crate::core::Uuid;
use rand::RngCore;
use crate::core::{Uuid};
impl Uuid {
pub fn random() -> Self {
let mut uuid =[0u8; 16];
let mut uuid = [0u8; 16];
rand::thread_rng().fill_bytes(&mut uuid);
Self {
value: hex::encode(uuid),