cleanup

server/src/telemetry/data.rs

@@ -0,0 +1,8 @@
+use crate::telemetry::data_item::TelemetryDataItem;
+use crate::telemetry::definition::TelemetryDefinition;
+
+#[derive(Clone)]
+pub struct TelemetryData {
+    pub definition: TelemetryDefinition,
+    pub data: tokio::sync::watch::Sender<Option<TelemetryDataItem>>,
+}

server/src/telemetry/data_item.rs

@@ -0,0 +1,8 @@
+use crate::telemetry::data_value::TelemetryDataValue;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TelemetryDataItem {
+    pub value: TelemetryDataValue,
+    pub timestamp: String,
+}

server/src/telemetry/data_type.rs

@@ -0,0 +1,38 @@
+use crate::core::TelemetryDataType;
+use serde::de::Visitor;
+use serde::{Deserializer, Serializer};
+use std::fmt::Formatter;
+
+pub fn tlm_data_type_serializer<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 Visitor<'_> 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"))
+    }
+}
+
+pub fn tlm_data_type_deserializer<'de, D>(deserializer: D) -> Result<TelemetryDataType, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    deserializer.deserialize_str(TlmDataTypeVisitor)
+}

server/src/telemetry/data_value.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum TelemetryDataValue {
+    Float32(f32),
+    Float64(f64),
+}

server/src/telemetry/definition.rs

@@ -0,0 +1,13 @@
+use crate::core::TelemetryDataType;
+use crate::telemetry::data_type::tlm_data_type_deserializer;
+use crate::telemetry::data_type::tlm_data_type_serializer;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TelemetryDefinition {
+    pub uuid: String,
+    pub name: String,
+    #[serde(serialize_with = "tlm_data_type_serializer")]
+    #[serde(deserialize_with = "tlm_data_type_deserializer")]
+    pub data_type: TelemetryDataType,
+}

server/src/telemetry/management_service.rs

@@ -0,0 +1,58 @@
+use crate::core::{TelemetryDefinitionRequest, Uuid};
+use crate::telemetry::data::TelemetryData;
+use crate::telemetry::definition::TelemetryDefinition;
+use papaya::HashMap;
+use std::error::Error;
+
+pub struct TelemetryManagementService {
+    uuid_index: HashMap<String, String>,
+    tlm_data: HashMap<String, TelemetryData>,
+}
+
+impl TelemetryManagementService {
+    pub fn new() -> Self {
+        Self {
+            uuid_index: HashMap::new(),
+            tlm_data: HashMap::new(),
+        }
+    }
+
+    pub fn register(
+        &self,
+        telemetry_definition_request: TelemetryDefinitionRequest,
+    ) -> Result<String, Box<dyn Error>> {
+        let uuid_index = self.uuid_index.pin();
+        let tlm_data = self.tlm_data.pin();
+
+        let uuid = uuid_index
+            .get_or_insert_with(telemetry_definition_request.name.clone(), || {
+                Uuid::random().value
+            })
+            .clone();
+
+        let _ = tlm_data.try_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,
+            },
+        );
+
+        Ok(uuid)
+    }
+
+    pub fn get_by_name(&self, name: &String) -> Option<TelemetryData> {
+        let uuid_index = self.uuid_index.pin();
+        let uuid = uuid_index.get(name)?;
+        self.get_by_uuid(uuid)
+    }
+
+    pub fn get_by_uuid(&self, uuid: &String) -> Option<TelemetryData> {
+        let tlm_data = self.tlm_data.pin();
+        tlm_data.get(uuid).cloned()
+    }
+}

server/src/telemetry/mod.rs

@@ -0,0 +1,6 @@
+pub mod data;
+pub mod data_item;
+pub mod data_type;
+pub mod data_value;
+pub mod definition;
+pub mod management_service;