fix: reduce requests to tari suite

src-tauri/src/binaries/binaries_manager.rs

@@ -32,6 +32,7 @@ pub(crate) struct BinaryManager {
     local_aviailable_versions_list: Vec<Version>,
     used_version: Option<Version>,
     adapter: Box<dyn LatestVersionApiAdapter>,
+    releases_cache_id: Option<String>,
 }
 
 impl BinaryManager {
@@ -41,6 +42,7 @@ impl BinaryManager {
         adapter: Box<dyn LatestVersionApiAdapter>,
         network_prerelease_prefix: Option<String>,
         should_validate_checksum: bool,
+        releases_cache_id: Option<String>,
     ) -> Self {
         let versions_requirements_data = match Network::get_current_or_user_setting_or_default() {
             Network::NextNet => include_str!("../../binaries_versions_nextnet.json"),
@@ -62,13 +64,80 @@ impl BinaryManager {
             local_aviailable_versions_list: Vec::new(),
             used_version: None,
             adapter,
+            releases_cache_id,
         }
     }
 
     pub fn binary_subfolder(&self) -> Option<&String> {
         self.binary_subfolder.as_ref()
     }
 
+    fn create_file_with_cached_releases(
+        &self,
+        data: Vec<VersionDownloadInfo>,
+    ) -> Result<(), Error> {
+        info!(target: LOG_TARGET, "Creating file with cached releases");
+        if self.releases_cache_id.is_none() {
+            return Err(anyhow!("No cache id provided"));
+        }
+
+        let binary_folder = self.adapter.get_binary_folder()?;
+        let cache_file = binary_folder.join(self.releases_cache_id.as_ref().unwrap());
+
+        let json_content = serde_json::to_string(&data)?;
+        std::fs::write(cache_file, json_content)?;
+
+        Ok(())
+    }
+
+    fn check_if_cached_releases_exist(&self) -> bool {
+        info!(target: LOG_TARGET, "Checking if cached releases exist");
+        if self.releases_cache_id.is_none() {
+            return false;
+        }
+
+        let binary_folder = self.adapter.get_binary_folder().ok();
+        let cache_file =
+            binary_folder.map(|path| path.join(self.releases_cache_id.as_ref().unwrap()));
+
+        cache_file.map_or(false, |path| path.exists())
+    }
+
+    fn read_cached_releases(&self) -> Result<Vec<VersionDownloadInfo>, Error> {
+        info!(target: LOG_TARGET, "Reading cached releases");
+        if self.releases_cache_id.is_none() {
+            return Err(anyhow!("No cache id provided"));
+        }
+
+        let binary_folder = self.adapter.get_binary_folder()?;
+        let cache_file = binary_folder.join(self.releases_cache_id.as_ref().unwrap());
+
+        let json_content = std::fs::read_to_string(cache_file)?;
+        let releases: Vec<VersionDownloadInfo> = serde_json::from_str(&json_content)?;
+
+        for release in &releases {
+            info!(target: LOG_TARGET, "Cached release: {:?}", release.version);
+        }
+
+        Ok(releases)
+    }
+
+    pub fn remove_cached_releases(&self) -> Result<(), Error> {
+        info!(target: LOG_TARGET, "Removing cached releases");
+        if self.releases_cache_id.is_none() {
+            return Err(anyhow!("No cache id provided"));
+        }
+
+        let binary_folder = self.adapter.get_binary_folder()?;
+        let cache_file = binary_folder.join(self.releases_cache_id.as_ref().unwrap());
+
+        if cache_file.exists() {
+            std::fs::remove_file(cache_file)?;
+        }
+
+        Ok(())
+    }
+
     fn read_version_requirements(binary_name: String, data_str: &str) -> VersionReq {
         let json_content: BinaryVersionsJsonContent =
             serde_json::from_str(data_str).unwrap_or_default();
@@ -329,7 +398,26 @@ impl BinaryManager {
     pub async fn check_for_updates(&mut self) {
         info!(target: LOG_TARGET,"Checking for updates for binary: {:?}", self.binary_name);
 
-        let versions_info = self.adapter.fetch_releases_list().await.unwrap_or_default();
+        let versions_info = match self.releases_cache_id {
+            Some(_) => {
+                info!(target: LOG_TARGET, "Reading cached releases");
+                if self.check_if_cached_releases_exist() {
+                    self.read_cached_releases().unwrap_or_default()
+                } else {
+                    let data = self.adapter.fetch_releases_list().await.unwrap_or_default();
+                    let _ = self.create_file_with_cached_releases(data.clone());
+
+                    data
+                }
+            }
+            None => {
+                info!(target: LOG_TARGET, "Fetching releases list");
+                let data = self.adapter.fetch_releases_list().await.unwrap_or_default();
+                let _ = self.create_file_with_cached_releases(data.clone());
+
+                data
+            }
+        };
 
         info!(target: LOG_TARGET,
             "Found {:?} versions for binary: {:?}",

src-tauri/src/binaries/binaries_resolver.rs

@@ -1,8 +1,10 @@
 use crate::ProgressTracker;
 use anyhow::{anyhow, Error};
 use async_trait::async_trait;
+use log::info;
 use regex::Regex;
 use semver::Version;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::LazyLock;
@@ -15,16 +17,18 @@ use super::adapter_xmrig::XmrigVersionApiAdapter;
 use super::binaries_manager::BinaryManager;
 use super::Binaries;
 
+pub const LOG_TARGET: &str = "tari::universe::binary_resolver";
+
 static INSTANCE: LazyLock<RwLock<BinaryResolver>> =
     LazyLock::new(|| RwLock::new(BinaryResolver::new()));
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct VersionDownloadInfo {
     pub(crate) version: Version,
     pub(crate) assets: Vec<VersionAsset>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct VersionAsset {
     pub(crate) url: String,
     pub(crate) name: String,
@@ -78,6 +82,7 @@ impl BinaryResolver {
                 Box::new(XmrigVersionApiAdapter {}),
                 None,
                 true,
+                Some("xmrig".to_string()),
             ),
         );
 
@@ -93,6 +98,7 @@ impl BinaryResolver {
                 }),
                 None,
                 true,
+                Some("tarigpuminer".to_string()),
             ),
         );
 
@@ -108,6 +114,7 @@ impl BinaryResolver {
                 }),
                 Some(tari_prerelease_prefix.to_string()),
                 true,
+                Some("tari-suite".to_string()),
             ),
         );
 
@@ -123,6 +130,7 @@ impl BinaryResolver {
                 }),
                 Some(tari_prerelease_prefix.to_string()),
                 true,
+                Some("tari-suite".to_string()),
             ),
         );
 
@@ -138,6 +146,7 @@ impl BinaryResolver {
                 }),
                 Some(tari_prerelease_prefix.to_string()),
                 true,
+                Some("tari-suite".to_string()),
             ),
         );
 
@@ -153,6 +162,7 @@ impl BinaryResolver {
                 }),
                 None,
                 true,
+                Some("sha-p2pool".to_string()),
             ),
         );
 
@@ -164,6 +174,7 @@ impl BinaryResolver {
                 Box::new(TorReleaseAdapter {}),
                 None,
                 true,
+                Some("tor".to_string()),
             ),
         );
 
@@ -208,6 +219,8 @@ impl BinaryResolver {
         progress_tracker: ProgressTracker,
         should_check_for_update: bool,
     ) -> Result<(), Error> {
+        info!(target: LOG_TARGET, "Initializing binary: {} | should check for update: {}", binary.name(), should_check_for_update);
+
         let manager = self
             .managers
             .get_mut(&binary)
@@ -256,6 +269,13 @@ impl BinaryResolver {
         Ok(())
     }
 
+    pub async fn remove_all_caches(&mut self) -> Result<(), Error> {
+        for manager in self.managers.values_mut() {
+            manager.remove_cached_releases()?;
+        }
+        Ok(())
+    }
+
     pub async fn update_binary(
         &mut self,
         binary: Binaries,

src-tauri/src/main.rs

@@ -735,6 +735,8 @@ async fn setup_inner(
             .await?;
     }
 
+    binary_resolver.remove_all_caches().await?;
+
     //drop binary resolver to release the lock
     drop(binary_resolver);
 

src-tauri/src/tor_adapter.rs

@@ -6,7 +6,6 @@ use log::{debug, info};
 use serde::{Deserialize, Serialize};
 use tari_shutdown::Shutdown;
 use tokio::fs;
-use tor_hash_passwd::EncryptedKey;
 
 use crate::{
     process_adapter::{
@@ -19,19 +18,16 @@ const LOG_TARGET: &str = "tari::universe::tor_adapter";
 
 pub(crate) struct TorAdapter {
     socks_port: u16,
-    password: String,
     config_file: Option<PathBuf>,
     config: TorConfig,
 }
 
 impl TorAdapter {
     pub fn new() -> Self {
         let socks_port = 9050;
-        let password = "tari is the best".to_string();
 
         Self {
             socks_port,
-            password,
             config_file: None,
             config: TorConfig::default(),
         }