Merge branch 'main' into chunked-downloads

Author: pepperoni505

.gitignore

@@ -4,6 +4,7 @@ _PackageInt
 .rollup.cache
 tsconfig.tsbuildinfo
 .vs
+examples/aircraft/NavigationDataInterfaceAircraftProject.xml.user
 examples/aircraft/PackageSources/html_ui/Pages/VCockpit/Instruments/Navigraph/NavigationDataInterfaceSample
 examples/aircraft/PackageSources/SimObjects/Airplanes/Navigraph_Navigation_Data_Interface_Aircraft/panel/msfs_navigation_data_interface.wasm
 out
@@ -32,4 +33,4 @@ target/
 .DS_Store
 
 test_work/
-dist
+dist

README.md

@@ -2,8 +2,8 @@
 
 The Navigraph Navigation Data Interface enables developers to download and integrate navigation data from Navigraph directly into add-on aircraft in MSFS.
 
-
 ## Key Features
+
 - Navigraph DFD Format: Leverage specialized support for Navigraph's DFD format, based on SQLite, which includes an SQL interface on the commbus for efficient data handling.
 - Javascript and WASM support: The navdata interface is accessible from both Javascript (Coherent) and WASM, providing flexibility for developers.
 - Supports updating of custom data formats.
@@ -29,22 +29,36 @@ Here's an overview on the structure of this repository, which is designed to be
 1. You'll need to either build the WASM module yourself (not recommended, but documented further down) or download it from [the latest release](https://github.com/Navigraph/msfs-navigation-data-interface/releases) (alternatively you can download it off of a commit by looking at the uploaded artifacts).
 2. Add the WASM module into your `panel` folder in `PackageSources`
 3. Add the following entry into `panel.cfg` (make sure to replace `NN` with the proper `VCockpit` ID):
+
    ```
    [VCockpitNN]
    size_mm=0,0
    pixel_size=0,0
    texture=NO_TEXTURE
    htmlgauge00=WasmInstrument/WasmInstrument.html?wasm_module=msfs_navigation_data_interface.wasm&wasm_gauge=navigation_data_interface,0,0,1,1
    ```
+
    - Note that if you already have a `VCockpit` with `NO_TEXTURE` you can just add another `htmlgauge` to it, while making sure to increase the index
+4. **Optional**: Create a `Navigraph/config.json` file to assist with Sentry reports. This info will be reported to us should any error occur in the library. We will use this to directly reach out to you (the developer) for these errors.
+
+    - The file must look like
+
+    ```json
+    {
+      "addon": {
+        "developer": "Navigraph",
+        "product": "Sample Aircraft"
+      }
+    }
+    ```
 
 ## Dealing with Bundled Navigation Data
 
-If you bundle outdated navigation data in your aircraft and you want this module to handle updating it for users with subscriptions, place the navigation data into the `NavigationData` directory in `PackageSources`. You can see an example [here](examples/aircraft/PackageSources/NavigationData/)
+If you bundle outdated navigation data in your aircraft and you want this module to handle updating it for users with subscriptions, place the navigation data into the `Navigraph/BundledData` directory in `PackageSources`. You can see an example [here](examples/aircraft/PackageSources/Navigraph/BundledData/)
 
 ## Where is the Navigation Data Stored?
 
-The default location for navigation data is `work/NavigationData`. If you have bundled navigation data, its located in the `NavigationData` folder in the root of your project. (although it gets copied into the `work` directory at runtime)
+The default location for navigation data is `work/NavigationData`.
 
 ## Building the Sample Aircraft
 

examples/aircraft/PackageDefinitions/navigraph-aircraft-navigation-data-interface-sample.xml

@@ -27,13 +27,13 @@
 			<AssetDir>PackageSources\Data\</AssetDir>
 			<OutputDir>Data\</OutputDir>
 		</AssetGroup>
-		<AssetGroup Name="NavigationData">
+		<AssetGroup Name="Navigraph">
 			<Type>Copy</Type>
 			<Flags>
 				<FSXCompatibility>false</FSXCompatibility>
 			</Flags>
-			<AssetDir>PackageSources\NavigationData\</AssetDir>
-			<OutputDir>NavigationData\</OutputDir>
+			<AssetDir>PackageSources\Navigraph\</AssetDir>
+			<OutputDir>Navigraph\</OutputDir>
 		</AssetGroup>
 		<AssetGroup Name="SimObject">
 			<Type>SimObject</Type>
@@ -53,4 +53,3 @@
 		</AssetGroup>
 	</AssetGroups>
 </AssetPackage>
-

examples/aircraft/PackageSources/NavigationData/cycle.json renamed to examples/aircraft/PackageSources/Navigraph/BundledData/cycle.json

@@ -0,0 +1,6 @@
+{
+    "addon": {
+        "developer": "Navigraph",
+        "product": "Sample Aircraft"
+    }
+}

examples/aircraft/PackageSources/NavigationData/db.s3db renamed to examples/aircraft/PackageSources/Navigraph/BundledData/db.s3db

@@ -0,0 +1,30 @@
+use std::fs::File;
+
+use serde::Deserialize;
+
+/// The path to an optional addon-specific config file containing data about the addon
+const ADDON_CONFIG_FILE: &str = ".\\Navigraph/config.json";
+
+/// Information about the current addon
+#[derive(Deserialize)]
+pub struct Addon {
+    pub developer: String,
+    pub product: String,
+}
+
+/// Configuration data provided by the developer
+#[derive(Deserialize)]
+pub struct Config {
+    pub addon: Addon,
+}
+
+impl Config {
+    /// Try to get the config
+    pub fn get_config() -> Option<Self> {
+        if let Ok(file) = File::open(ADDON_CONFIG_FILE) {
+            serde_json::from_reader(file).ok()
+        } else {
+            None
+        }
+    }
+}

examples/aircraft/PackageSources/Navigraph/config.json

@@ -3,10 +3,11 @@ mod utils;
 
 use anyhow::{anyhow, Result};
 use once_cell::sync::Lazy;
+use sentry::integrations::anyhow::capture_anyhow;
 use serde::Deserialize;
 use std::{
     cmp::Ordering,
-    fs::{self, File},
+    fs::{self, read_dir, File},
     path::{Path, PathBuf},
     sync::Mutex,
 };
@@ -45,79 +46,41 @@ pub const WORK_NAVIGATION_DATA_FOLDER: &str = "\\work/NavigationData";
 pub const WORK_CYCLE_JSON_PATH: &str = "\\work/NavigationData/cycle.json";
 /// The path to the "master" SQLite DB
 pub const WORK_DB_PATH: &str = "\\work/NavigationData/db.s3db";
-/// The path to the layout.json in the addon folder
-pub const LAYOUT_JSON: &str = ".\\layout.json";
 /// The folder name for bundled navigation data
-pub const BUNDLED_FOLDER_NAME: &str = "NavigationData";
+pub const BUNDLED_FOLDER_NAME: &str = ".\\Navigraph/BundledData";
 
 /// The global exported database state
 pub static DATABASE_STATE: Lazy<Mutex<DatabaseState>> =
-    Lazy::new(|| Mutex::new(DatabaseState::new().unwrap())); // SAFETY: the only way this function can return an error is if layout.json is corrupt (which is impossible since the package wouldn't even mount), or if copying to the work folder is failing (in which case we have more fundamental problems). So overall, unwrapping here is safe
-
-/// An entry in the layout.json file
-#[derive(Deserialize)]
-struct LayoutEntry {
-    path: String,
-}
-
-/// The representation of the layout.json file
-#[derive(Deserialize)]
-struct LayoutJson {
-    content: Vec<LayoutEntry>,
-}
+    Lazy::new(|| Mutex::new(DatabaseState::new()));
 
 /// Find the bundled navigation data distribution
 fn get_bundled_db() -> Result<Option<DatabaseDistributionInfo>> {
-    // Since we don't know the exact filenames of the bundled navigation data,
-    // we need to find them through the layout.json file. In a perfect world,
-    // we would just enumerate the bundled directory. However, fd_readdir is unreliable in the sim.
-    let mut layout = fs::read_to_string(LAYOUT_JSON)?;
-    let parsed = serde_json::from_str::<LayoutJson>(&mut layout)?;
-
-    // Filter out the files in the layout that are not in the bundled folder
-    let bundled_files = parsed
-        .content
-        .iter()
-        .filter_map(|e| {
-            let path = Path::new(&e.path);
-
-            // Get parent
-            let (Some(parent), Some(filename)) = (path.parent(), path.file_name()) else {
-                return None;
-            };
-
-            // Ensure the file is within our known bundled data path
-            if parent != Path::new(BUNDLED_FOLDER_NAME) {
-                return None;
-            };
-
-            // Finally, return just the basename
-            filename.to_str()
-        })
-        .collect::<Vec<_>>();
+    let bundled_entries = match read_dir(BUNDLED_FOLDER_NAME) {
+        Ok(dir) => dir.filter_map(Result::ok).collect::<Vec<_>>(),
+        Err(_) => return Ok(None),
+    };
 
-    // Try extracting the cycle info and DB files
-    let cycle_info = if let Some(file) = bundled_files
+    // Try finding cycle.json
+    let Some(cycle_file_name) = bundled_entries
         .iter()
-        .find(|f| f.to_lowercase().ends_with(".json"))
-    {
-        file
-    } else {
+        .filter_map(|e| e.file_name().to_str().map(|s| s.to_owned()))
+        .find(|e| *e == String::from("cycle.json"))
+    else {
         return Ok(None);
     };
 
-    let db_file = if let Some(file) = bundled_files
+    // Try finding the DB (we don't know the full filename, only extension)
+    let Some(db_file_name) = bundled_entries
         .iter()
-        .find(|f| f.to_lowercase().ends_with(".s3db"))
-    {
-        file
-    } else {
+        .filter_map(|e| e.file_name().to_str().map(|s| s.to_owned()))
+        .find(|e| e.ends_with(".s3db"))
+    else {
         return Ok(None);
     };
 
     Ok(Some(DatabaseDistributionInfo::new(
-        Path::new(&format!(".\\{BUNDLED_FOLDER_NAME}\\{cycle_info}")), // We need to reconstruct the bundled path to include the proper syntax to reference non-work folder files
-        Path::new(&format!(".\\{BUNDLED_FOLDER_NAME}\\{db_file}")),
+        Path::new(&format!(".\\{BUNDLED_FOLDER_NAME}\\{cycle_file_name}")), // We need to reconstruct the bundled path to include the proper syntax to reference non-work folder files
+        Path::new(&format!(".\\{BUNDLED_FOLDER_NAME}\\{db_file_name}")),
     )?))
 }
 
@@ -177,11 +140,26 @@ pub struct DatabaseState {
 
 impl DatabaseState {
     /// Create a database state, intended to only be instantiated once (held in the DATABASE_STATE static)
-    ///
-    /// This searches for the best DB to use by comparing the cycle and revision of both the downloaded (in work folder) and bundled navigation data.
-    fn new() -> Result<Self> {
+    fn new() -> Self {
         // Start out with a fresh instance
         let mut instance = Self::default();
+
+        // Try to load a DB
+        match instance.try_load_db() {
+            Ok(()) => {}
+            Err(e) => {
+                capture_anyhow(&e);
+                println!("[NAVIGRAPH]: Error trying to load DB: {e}");
+            }
+        }
+
+        instance
+    }
+
+    /// Try to load a database (either bundled or downloaded)
+    ///
+    /// This searches for the best DB to use by comparing the cycle and revision of both the downloaded (in work folder) and bundled navigation data.
+    fn try_load_db(&mut self) -> Result<()> {
         // Get distribution info of both bundled and downloaded DBs, if they exist
         let bundled_distribution = get_bundled_db()?;
         let downloaded_distribution =
@@ -221,7 +199,7 @@ impl DatabaseState {
 
         // If we somehow don't have a cycle in bundled or downloaded, return an empty instance
         let Some(latest) = latest else {
-            return Ok(instance);
+            return Ok(());
         };
 
         // Ensure parent folder exists (ignore the result as it will return an error if it already exists)
@@ -236,9 +214,9 @@ impl DatabaseState {
         }
 
         // The only way this can fail (since we know now that the path is valid) is if the file is corrupt, in which case we should report to sentry
-        instance.open_connection()?;
+        self.open_connection()?;
 
-        Ok(instance)
+        return Ok(());
     }
 
     fn get_database(&self) -> Result<&Connection> {

src/wasm/src/config.rs

@@ -7,9 +7,15 @@ use sentry::{integrations::anyhow::capture_anyhow, protocol::Context};
 use sentry_gauge::{wrap_gauge_with_sentry, SentryGauge};
 use serde::Serialize;
 
+/// Developer-configured values for interface
+mod config;
+/// SQLite mapping implementation
 mod database;
+/// Interface function definitions
 mod funcs;
+/// Futures implementations for use in interface functions
 mod futures;
+/// The sentry wrapper implementation around the MSFS gauge callbacks
 mod sentry_gauge;
 
 /// Amount of MS between dispatches of the heartbeat commbus event

src/wasm/src/database/mod.rs

@@ -1,5 +1,5 @@
 use std::{
-    fs::{File, OpenOptions},
+    fs::OpenOptions,
     sync::{Arc, Mutex},
     time::{Duration, Instant},
 };
@@ -15,8 +15,7 @@ use sentry::integrations::anyhow::capture_anyhow;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-/// The path to the manifest.json in the addon folder
-const MANIFEST_FILE_PATH: &str = ".\\manifest.json";
+use crate::config::Config;
 
 /// The path to the sentry persistent state file
 const SENTRY_FILE: &str = "\\work/ng_sentry.json";
@@ -131,6 +130,8 @@ impl SentryPersistentState {
     ///
     /// Note: This MUST be called every frame, otherwise we *will* miss state updates on requests as DataReady is only available for a single frame
     pub fn update(&mut self) -> Result<()> {
+        let initial_reports_size = self.reports.len();
+
         self.reports.retain_mut(|r| {
             // Get the request in the report. If one does not exist, create a request
             let Some(request) = r.request else {
@@ -142,7 +143,10 @@ impl SentryPersistentState {
             request.state() != NetworkRequestState::DataReady
         });
 
-        self.flush()?;
+        // Only flush if reports size changed
+        if self.reports.len() != initial_reports_size {
+            self.flush()?;
+        }
 
         Ok(())
     }
@@ -242,38 +246,28 @@ where
         },
     ));
 
-    // In order to track what addon the reports are coming from, we need to parse the manifest.json file to extract relevant info
-    let manifest = {
-        #[derive(Deserialize)]
-        struct Manifest {
-            title: String,
-            creator: String,
-            package_version: String,
-        }
-        let manifest_file = File::open(MANIFEST_FILE_PATH)?;
-        serde_json::from_reader::<_, Manifest>(manifest_file)?
-    };
-
     // Get the user ID from persistent state
     let user_id = SENTRY_STATE
         .try_lock()
         .map_err(|_| anyhow!("Unable to lock SENTRY_STATE"))?
         .user_id
         .to_string();
 
-    // Configure the sentry scope to report the user ID and plugin info loaded from manifest.json
+    // Configure the sentry scope to report the user ID and addon info
     sentry::configure_scope(|scope| {
         scope.set_user(Some(sentry::User {
             id: Some(user_id),
             ..Default::default()
         }));
 
+        let config = Config::get_config();
+        scope.set_tag(
+            "developer",
+            config.as_ref().map_or("unknown", |c| &c.addon.developer),
+        );
         scope.set_tag(
-            "plugin",
-            format!(
-                "{}/{}@{}",
-                manifest.creator, manifest.title, manifest.package_version
-            ),
+            "product",
+            config.as_ref().map_or("unknown", |c| &c.addon.product),
         );
     });