non-blocking updater; wip

regolith-labs · Feb 28, 2025 · 67d9285 · 67d9285
1 parent 1a2789b
commit 67d9285
Showing 1 changed file with 50 additions and 47 deletions.
diff --git a/src/components/updater/mod.rs b/src/components/updater/mod.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use dioxus::prelude::*;
 
 use anyhow::Result;
@@ -9,52 +11,45 @@ const ENDPOINT: &str = "https://api.ore.supply/app/update/{{target}}/{{arch}}/{{
 const PUBKEY: &str = "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEE1RkFDQUFCQ0M0NDhBRTQKUldUa2lrVE1xOHI2cGJSaXdCS0NVWGdBQTYzSGFNTXlBRlc5NThYVFhwUEVab29UaGpiSk1WWloK";
 
 pub fn Updater() -> Element {
-    let state = use_resource(move || async move { updater() });
+    let signal = use_signal(|| State::AlreadyHaveLatest);
+    updater(signal);
     rsx! {
-        match &*state.read() {
-            Some(Ok(state)) => {
-                match state {
-                    State::AlreadyHaveLatest => {
-                        rsx! {}
-                    }
-                    State::UpdateAvailable(update, binary) => {
-                        let update = update.clone();
-                        let binary = binary.clone();
-                        rsx! {
-                            button {
-                                class: "text-xl",
-                                onclick: move |_| {
-                                    let update = update.clone();
-                                    let binary = binary.clone();
-                                    spawn(async move {
-                                        if let Err(err) = update.install(binary) {
-                                            println!("{:?}", err);
-                                        }
-                                    });
-                                },
-                                "update?"
-                            }
-                        }
+        match signal.cloned() {
+            State::AlreadyHaveLatest => {
+                rsx! {}
+            }
+            State::UpdateAvailable(update, binary) => {
+                let update = update.clone();
+                let binary = Arc::clone(&binary);
+                rsx! {
+                    button {
+                        class: "text-xl",
+                        onclick: move |_| {
+                            let update = update.clone();
+                            let binary = Arc::clone(&binary);
+                            spawn(async move {
+                                if let Err(err) = update.install(binary) {
+                                    log::error!("{:?}", err);
+                                }
+                            });
+                        },
+                        "update?"
                     }
                 }
             }
-             _ => {
-                rsx! {}
-            }
         }
     }
 }
 
 #[derive(Clone)]
 enum State {
     AlreadyHaveLatest,
-    UpdateAvailable(Update, NewBinaryToInstall),
+    UpdateAvailable(Update, Arc<NewBinaryToInstall>),
 }
 type NewBinaryToInstall = Vec<u8>;
 
-fn updater() -> Result<State> {
+fn updater(mut signal: Signal<State>) -> Result<()> {
     let endpoint = Url::parse(ENDPOINT)?;
-    println!("{:?}", endpoint);
     // signer pubkey
     let pubkey = String::from(PUBKEY);
     // config
@@ -66,30 +61,38 @@ fn updater() -> Result<State> {
     // current version for reference
     let current_version = env!("CARGO_PKG_VERSION");
     let current_version = Version::parse(current_version)?;
+    // channel
+    let (sender, receiver) = tokio::sync::oneshot::channel::<State>();
     // check for update
     let handle = std::thread::spawn(move || {
-        let update = cargo_packager_updater::check_update(current_version, config)?;
-        if let Some(update) = update {
-            println!("update: {:?}", update);
+        let update = cargo_packager_updater::check_update(current_version, config);
+        let state = if let Ok(Some(update)) = update {
+            log::info!("update: {:?}", update);
             // download
-            let bytes = update.download()?;
-            Ok(State::UpdateAvailable(update, bytes))
+            if let Ok(bytes) = update.download() {
+                State::UpdateAvailable(update, Arc::new(bytes))
+            } else {
+                log::error!("failed to download latest update");
+                State::AlreadyHaveLatest
+            }
         } else {
-            println!("no update available");
-            Ok(State::AlreadyHaveLatest)
+            log::info!("no update available");
+            State::AlreadyHaveLatest
+        };
+        if let Err(err) = sender.send(state) {
+            log::error!("{:?}", err);
         }
     });
-    match handle.join() {
-        Ok(res) => match res {
-            ok @ Ok(_) => ok,
+    // spawn dioxus thread to listen for update
+    spawn(async move {
+        match receiver.await {
+            Ok(state) => {
+                signal.set(state);
+            }
             Err(err) => {
                 log::error!("{:?}", err);
-                Err(err)
             }
-        },
-        Err(err) => {
-            log::error!("{:?}", err);
-            Err(anyhow::anyhow!("failed to join thread from updater"))
         }
-    }
+    });
+    Ok(())
 }