Merge #1580: Fix export subscription

a12bb0b gui: add logs when export_subscription() fail to send a message (pythcoiner)
aa0c5d3 gui: minor cleanup in export_subscription() (pythcoiner)
3513226 gui: fix the export subscription being stuck in Running state (pythcoiner)
85024d6 gui: ExportModal.update() pass an ExportMessage instead app::message::Message in order to be used in a more generic way (pythcoiner)

Pull request description:

  fix a bug introduced in #1550 where the export subscription were stuck in `Running` state & minor cleanups

ACKs for top commit:
  edouardparis:
    ACK a12bb0b

Tree-SHA512: 62dd0bbcb46a5d53d959af2a4d924c7b4308b985c3e26d0c2bce5a99607fa4934a393447d7044fb503f89a8a7c2208365d129f1bb191a0a91b60036f584a6d35

Author: edouardparis

liana-gui/src/app/state/export.rs

@@ -9,7 +9,7 @@ use tokio::task::JoinHandle;
 
 use crate::{
     app::{
-        message::Message,
+        self,
         view::{self, export::export_modal},
     },
     daemon::Daemon,
@@ -37,53 +37,47 @@ impl ExportModal {
         }
     }
 
-    pub fn launch(&self) -> Task<Message> {
+    pub fn launch(&self) -> Task<app::message::Message> {
         Task::perform(get_path(), |m| {
-            Message::View(view::Message::Export(ExportMessage::Path(m)))
+            app::message::Message::View(view::Message::Export(ExportMessage::Path(m)))
         })
     }
 
-    pub fn update(&mut self, message: Message) -> Task<Message> {
-        if let Message::View(view::Message::Export(m)) = message {
-            match m {
-                ExportMessage::ExportProgress(m) => match m {
-                    ExportProgress::Started(handle) => {
-                        self.handle = Some(handle);
-                        self.state = ExportState::Progress(0.0);
-                    }
-                    ExportProgress::Progress(p) => {
-                        if let ExportState::Progress(_) = self.state {
-                            self.state = ExportState::Progress(p);
-                        }
-                    }
-                    ExportProgress::Finished | ExportProgress::Ended => {
-                        self.state = ExportState::Ended
-                    }
-                    ExportProgress::Error(e) => self.error = Some(e),
-                    ExportProgress::None => {}
-                },
-                ExportMessage::TimedOut => {
-                    self.stop(ExportState::TimedOut);
-                }
-                ExportMessage::UserStop => {
-                    self.stop(ExportState::Aborted);
+    pub fn update(&mut self, message: ExportMessage) -> Task<app::message::Message> {
+        match message {
+            ExportMessage::ExportProgress(m) => match m {
+                ExportProgress::Started(handle) => {
+                    self.handle = Some(handle);
+                    self.state = ExportState::Progress(0.0);
                 }
-                ExportMessage::Path(p) => {
-                    if let Some(path) = p {
-                        self.path = Some(path);
-                        self.start();
-                    } else {
-                        return Task::perform(async {}, |_| {
-                            Message::View(view::Message::Export(ExportMessage::Close))
-                        });
+                ExportProgress::Progress(p) => {
+                    if let ExportState::Progress(_) = self.state {
+                        self.state = ExportState::Progress(p);
                     }
                 }
-                ExportMessage::Close | ExportMessage::Open => { /* unreachable */ }
+                ExportProgress::Finished | ExportProgress::Ended => self.state = ExportState::Ended,
+                ExportProgress::Error(e) => self.error = Some(e),
+                ExportProgress::None => {}
+            },
+            ExportMessage::TimedOut => {
+                self.stop(ExportState::TimedOut);
             }
-            Task::none()
-        } else {
-            Task::none()
+            ExportMessage::UserStop => {
+                self.stop(ExportState::Aborted);
+            }
+            ExportMessage::Path(p) => {
+                if let Some(path) = p {
+                    self.path = Some(path);
+                    self.start();
+                } else {
+                    return Task::perform(async {}, |_| {
+                        app::message::Message::View(view::Message::Export(ExportMessage::Close))
+                    });
+                }
+            }
+            ExportMessage::Close | ExportMessage::Open => { /* unreachable */ }
         }
+        Task::none()
     }
     pub fn view<'a>(&'a self, content: Element<'a, view::Message>) -> Element<view::Message> {
         let modal = Modal::new(

liana-gui/src/app/state/transactions.rs

@@ -279,10 +279,16 @@ impl State for TransactionsPanel {
                     self.modal = TransactionsModal::None;
                 }
             }
-            _ => {
+            ref msg => {
                 return match &mut self.modal {
                     TransactionsModal::CreateRbf(modal) => modal.update(daemon, _cache, message),
-                    TransactionsModal::Export(modal) => modal.update(message),
+                    TransactionsModal::Export(modal) => {
+                        if let Message::View(view::Message::Export(m)) = msg {
+                            modal.update(m.clone())
+                        } else {
+                            Task::none()
+                        }
+                    }
                     TransactionsModal::None => Task::none(),
                 };
             }

liana-gui/src/export.rs

@@ -359,15 +359,14 @@ pub fn export_subscription(
                 Status::Stopped => {
                     break;
                 }
-                Status::Running => {
-                    sleep(time::Duration::from_millis(100)).await;
-                    continue;
-                }
+                Status::Running => {}
             }
             let msg = state.receiver.try_recv();
             let disconnected = match msg {
                 Ok(m) => {
-                    let _ = output.send(m).await;
+                    if let Err(e) = output.send(m).await {
+                        tracing::error!("export_subscription() fail to send message: {}", e);
+                    }
                     continue;
                 }
                 Err(e) => match e {
@@ -379,7 +378,9 @@ pub fn export_subscription(
             let handle = match state.handle.take() {
                 Some(h) => h,
                 None => {
-                    let _ = output.send(ExportProgress::Error(Error::HandleLost)).await;
+                    if let Err(e) = output.send(ExportProgress::Error(Error::HandleLost)).await {
+                        tracing::error!("export_subscription() fail to send message: {}", e);
+                    }
                     continue;
                 }
             };
@@ -394,14 +395,14 @@ pub fn export_subscription(
                 }
             };
             if let Some(msg) = msg {
-                let _ = output.send(msg).await;
+                if let Err(e) = output.send(msg).await {
+                    tracing::error!("export_subscription() fail to send message: {}", e);
+                }
                 continue;
             }
-            // => release handle lock
             state.handle = Some(handle);
 
             sleep(time::Duration::from_millis(100)).await;
-            let _ = output.send(ExportProgress::None).await;
         }
     })
 }