adds saving and loading history to and from disk

server/src/telemetry/management_service.rs

@@ -1,30 +1,84 @@
+use std::fs;
+use std::fs::File;
 use crate::core::{TelemetryDefinitionRequest, Uuid};
-use crate::telemetry::data::{TelemetryData, TelemetryDataHistory};
+use crate::telemetry::data::TelemetryData;
 use crate::telemetry::definition::TelemetryDefinition;
 use crate::telemetry::history::{TelemetryHistory, TelemetryHistoryService};
 use papaya::{HashMap, HashMapRef, LocalGuard};
-use std::error::Error;
 use std::hash::RandomState;
+use std::io::{Read, Write};
+use std::sync::Arc;
+use std::time::Duration;
+use log::{error, info, warn};
+use tokio::sync::Mutex;
+use tokio::time::sleep;
+
+const RELEASED_ATTEMPTS: usize = 5;
 
 pub struct TelemetryManagementService {
     uuid_index: HashMap<String, String>,
-    tlm_data: HashMap<String, TelemetryDataHistory>,
-    telemetry_history_service: TelemetryHistoryService,
+    tlm_data: HashMap<String, Arc<TelemetryHistory>>,
+    telemetry_history_service: Arc<TelemetryHistoryService>,
+    metadata_file: Arc<Mutex<File>>,
 }
 
 impl TelemetryManagementService {
-    pub fn new(telemetry_history_service: TelemetryHistoryService) -> Self {
-        Self {
-            uuid_index: HashMap::new(),
-            tlm_data: HashMap::new(),
-            telemetry_history_service,
+    pub fn new(telemetry_history_service: TelemetryHistoryService) -> anyhow::Result<Self> {
+        let metadata_file = telemetry_history_service.get_metadata_file();
+
+        let uuid_index = HashMap::new();
+        let tlm_data = HashMap::new();
+
+        // TODO: Load metadata from file
+        match File::open(&metadata_file) {
+            Ok(mut metadata_file) => {
+                let uuid_index = uuid_index.pin();
+                let tlm_data = tlm_data.pin();
+
+                // Read all data from the file
+                let mut data = String::new();
+                metadata_file.read_to_string(&mut data)?;
+                drop(metadata_file);
+
+                // Each line is a separate entry
+                for line in data.split("\n") {
+                    if line.is_empty() {
+                        // Skip empty lines
+                        continue;
+                    }
+                    // Skip invalid entries
+                    match serde_json::from_str::<TelemetryDefinition>(line) {
+                        Ok(tlm_def) => {
+                            let _ = uuid_index.insert(tlm_def.name.clone(), tlm_def.uuid.clone());
+                            let _ = tlm_data.insert(tlm_def.uuid.clone(), Arc::new(tlm_def.into()));
+                        },
+                        Err(err) => {
+                            error!("Failed to parse metadata entry {err}");
+                        },
+                    }
+                }
+            }
+            Err(err) => {
+                warn!("Failed to open metadata file {err}. Continuing");
+            }
         }
+
+        Ok(Self {
+            uuid_index,
+            tlm_data,
+            telemetry_history_service: Arc::new(telemetry_history_service),
+            metadata_file: Arc::new(Mutex::new(fs::OpenOptions::new()
+                .create(true)
+                .write(true)
+                .append(true)
+                .open(metadata_file)?))
+        })
     }
 
     pub fn register(
         &self,
         telemetry_definition_request: TelemetryDefinitionRequest,
-    ) -> Result<String, Box<dyn Error>> {
+    ) -> anyhow::Result<String> {
         let uuid_index = self.uuid_index.pin();
         let tlm_data = self.tlm_data.pin();
 
@@ -34,21 +88,47 @@ impl TelemetryManagementService {
             })
             .clone();
 
-        let _ = tlm_data.try_insert(
+        let inserted = tlm_data.try_insert(
             uuid.clone(),
-            TelemetryDataHistory {
-                data: 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,
-                },
-                history: TelemetryHistory::new(),
-            },
+            Arc::new(TelemetryDefinition {
+                uuid: uuid.clone(),
+                name: telemetry_definition_request.name.clone(),
+                data_type: telemetry_definition_request.data_type(),
+            }.into()),
         );
 
+        match inserted {
+            Ok(newly_inserted) => {
+                // This data also needs to be written to disk
+                let file = self.metadata_file.clone();
+                let newly_inserted = newly_inserted.data.definition.clone();
+                tokio::spawn(async move {
+                    let mut file = file.lock_owned().await;
+                    let newly_inserted = serde_json::to_string(&newly_inserted);
+                    match newly_inserted {
+                        Ok(newly_inserted) => {
+                            if let Err(err) = file.write(newly_inserted.as_bytes()) {
+                                error!("Failed to write TelemetryDefinition to file {err}");
+                                return;
+                            }
+                            if let Err(err) = file.write("\n".as_bytes()) {
+                                error!("Failed to write newline to file {err}");
+                                return;
+                            }
+                            if let Err(err) = file.flush() {
+                                error!("Failed to flush file {err}");
+                                return;
+                            }
+                        },
+                        Err(err) => {
+                            error!("Failed to serialize TelemetryDefinition {err}");
+                        },
+                    }
+                });
+            }
+            Err(_) => {},
+        }
+
         Ok(uuid)
     }
 
@@ -72,17 +152,51 @@ impl TelemetryManagementService {
         }
     }
 
-    pub fn history_service(&self) -> &TelemetryHistoryService {
-        &self.telemetry_history_service
+    pub fn history_service(&self) -> Arc<TelemetryHistoryService> {
+        self.telemetry_history_service.clone()
+    }
+
+    pub async fn cleanup(self) -> anyhow::Result<()> {
+        info!("Saving Telemetry");
+        let history_service = self.telemetry_history_service;
+        let metadata_file = self.metadata_file;
+        let tlm_data = self.tlm_data.pin_owned();
+        let mut tasks = vec![];
+
+        for _ in 0..RELEASED_ATTEMPTS {
+            if Arc::strong_count(&history_service) != 1 {
+                sleep(Duration::from_secs(1)).await;
+            }
+        }
+        if Arc::strong_count(&history_service) != 1 {
+            warn!("History Service Has not been released after {RELEASED_ATTEMPTS} attempts!");
+        }
+
+        for data_history in tlm_data.values() {
+            tasks.push(data_history.cleanup(&history_service));
+        }
+        {
+            if let Some(tlm) = Arc::into_inner(metadata_file) {
+                tlm.into_inner().sync_all()?;
+            } else {
+                error!("Could not close metadata file: still in use")
+            }
+        }
+
+        for task in tasks {
+            task.await?;
+        }
+
+        Ok(())
     }
 }
 
 pub struct TelemetryManagementServicePin<'a> {
-    tlm_data: HashMapRef<'a, String, TelemetryDataHistory, RandomState, LocalGuard<'a>>,
+    tlm_data: HashMapRef<'a, String, Arc<TelemetryHistory>, RandomState, LocalGuard<'a>>,
 }
 
 impl<'a> TelemetryManagementServicePin<'a> {
-    pub fn get_by_uuid(&'a self, uuid: &String) -> Option<&'a TelemetryDataHistory> {
+    pub fn get_by_uuid(&'a self, uuid: &String) -> Option<&'a Arc<TelemetryHistory>> {
         self.tlm_data.get(uuid)
     }
 }