applies formatting and linting

server/src/telemetry/management_service.rs

@@ -1,15 +1,15 @@
-use std::fs;
-use std::fs::File;
 use crate::core::{TelemetryDefinitionRequest, Uuid};
 use crate::telemetry::data::TelemetryData;
 use crate::telemetry::definition::TelemetryDefinition;
 use crate::telemetry::history::{TelemetryHistory, TelemetryHistoryService};
+use log::{error, info, warn};
 use papaya::{HashMap, HashMapRef, LocalGuard};
+use std::fs;
+use std::fs::File;
 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;
 
@@ -51,10 +51,10 @@ impl TelemetryManagementService {
                         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}");
-                        },
+                        }
                     }
                 }
             }
@@ -67,11 +67,12 @@ impl TelemetryManagementService {
             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)?))
+            metadata_file: Arc::new(Mutex::new(
+                fs::OpenOptions::new()
+                    .create(true)
+                    .append(true)
+                    .open(metadata_file)?,
+            )),
         })
     }
 
@@ -90,43 +91,42 @@ impl TelemetryManagementService {
 
         let inserted = tlm_data.try_insert(
             uuid.clone(),
-            Arc::new(TelemetryDefinition {
-                uuid: uuid.clone(),
-                name: telemetry_definition_request.name.clone(),
-                data_type: telemetry_definition_request.data_type(),
-            }.into()),
+            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}");
-                        },
+        if let Ok(newly_inserted) = 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}");
+                        }
                     }
-                });
-            }
-            Err(_) => {},
+                    Err(err) => {
+                        error!("Failed to serialize TelemetryDefinition {err}");
+                    }
+                }
+            });
         }
 
         Ok(uuid)