Error feedback for the user upon communication errors

If communication with the other party fails the program should stop and the user should see the respective error.
Communication errors are handled in the event-loop. Upon a communication error the event loop is stopped.
Since the event loop is only stopped upon error the Result returned from the event loop is Infallible.

If one of the two futures, event loop and swap,  finishes (success/failure) the other future should be stopped as well.
We use tokio::selec! to stop either future if the other stops.

swap/src/bin/swap_cli.rs

@@ -118,8 +118,16 @@ async fn main() -> Result<()> {
             );
             let (swap, event_loop) = bob_factory.with_init_params(send_bitcoin).build().await?;
 
-            tokio::spawn(async move { event_loop.run().await });
+            let handle = tokio::spawn(async move { event_loop.run().await });
-            bob::run(swap).await?;
+            let swap = bob::run(swap);
+            tokio::select! {
+                event_loop_result = handle => {
+                    event_loop_result??;
+                },
+                swap_result = swap => {
+                    swap_result?;
+                }
+            }
         }
         Command::History => {
             let mut table = Table::new();
@@ -159,9 +167,16 @@ async fn main() -> Result<()> {
                 execution_params,
             );
             let (swap, event_loop) = bob_factory.build().await?;
-
+            let handle = tokio::spawn(async move { event_loop.run().await });
-            tokio::spawn(async move { event_loop.run().await });
+            let swap = bob::run(swap);
-            bob::run(swap).await?;
+            tokio::select! {
+                event_loop_result = handle => {
+                    event_loop_result??;
+                },
+                swap_result = swap => {
+                    swap_result?;
+                }
+            }
         }
         Command::Cancel(Cancel::BuyXmr {
             swap_id,
@@ -191,27 +206,33 @@ async fn main() -> Result<()> {
                 execution_params,
             );
             let (swap, event_loop) = bob_factory.build().await?;
+            let handle = tokio::spawn(async move { event_loop.run().await });
 
-            tokio::spawn(async move { event_loop.run().await });
+            let cancel = bob::cancel(
-
-            match bob::cancel(
                 swap.swap_id,
                 swap.state,
                 swap.bitcoin_wallet,
                 swap.db,
                 force,
-            )
+            );
-            .await?
+
-            {
+            tokio::select! {
-                Ok((txid, _)) => {
+                event_loop_result = handle => {
-                    info!("Cancel transaction successfully published with id {}", txid)
+                    event_loop_result??;
-                }
+                },
-                Err(CancelError::CancelTimelockNotExpiredYet) => error!(
+                cancel_result = cancel => {
-                    "The Cancel Transaction cannot be published yet, \
+                    match cancel_result? {
-                    because the timelock has not expired. Please try again later."
+                        Ok((txid, _)) => {
-                ),
+                            info!("Cancel transaction successfully published with id {}", txid)
-                Err(CancelError::CancelTxAlreadyPublished) => {
+                        }
-                    warn!("The Cancel Transaction has already been published.")
+                        Err(CancelError::CancelTimelockNotExpiredYet) => error!(
+                            "The Cancel Transaction cannot be published yet, \
+                            because the timelock has not expired. Please try again later."
+                        ),
+                        Err(CancelError::CancelTxAlreadyPublished) => {
+                            warn!("The Cancel Transaction has already been published.")
+                        }
+                    }
                 }
             }
         }
@@ -244,19 +265,26 @@ async fn main() -> Result<()> {
             );
             let (swap, event_loop) = bob_factory.build().await?;
 
-            tokio::spawn(async move { event_loop.run().await });
+            let handle = tokio::spawn(async move { event_loop.run().await });
-            bob::refund(
+            let refund = bob::refund(
                 swap.swap_id,
                 swap.state,
                 swap.execution_params,
                 swap.bitcoin_wallet,
                 swap.db,
                 force,
-            )
+            );
-            .await??;
+
+            tokio::select! {
+                event_loop_result = handle => {
+                    event_loop_result??;
+                },
+                refund_result = refund => {
+                    refund_result??;
+                }
+            }
         }
     };
-
     Ok(())
 }
 

swap/src/protocol/bob.rs

@@ -225,7 +225,9 @@ impl From<transfer_proof::OutEvent> for OutEvent {
                 channel,
             },
             AckSent => OutEvent::ResponseSent,
-            Failure(err) => OutEvent::CommunicationError(err.context("Failure with Transfer Proof")),
+            Failure(err) => {
+                OutEvent::CommunicationError(err.context("Failure with Transfer Proof"))
+            }
         }
     }
 }
@@ -235,7 +237,9 @@ impl From<encrypted_signature::OutEvent> for OutEvent {
         use encrypted_signature::OutEvent::*;
         match event {
             Acknowledged => OutEvent::EncryptedSignatureAcknowledged,
-            Failure(err) => OutEvent::CommunicationError(err.context("Failure with Encrypted Signature")),
+            Failure(err) => {
+                OutEvent::CommunicationError(err.context("Failure with Encrypted Signature"))
+            }
         }
     }
 }

swap/src/protocol/bob/event_loop.rs

@@ -7,10 +7,10 @@ use crate::{
         bob::{Behaviour, OutEvent, QuoteRequest, State0, State2},
     },
 };
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, bail, Result};
 use futures::FutureExt;
 use libp2p::{core::Multiaddr, PeerId};
-use std::sync::Arc;
+use std::{convert::Infallible, sync::Arc};
 use tokio::sync::mpsc::{Receiver, Sender};
 use tracing::{debug, error, info};
 
@@ -167,7 +167,7 @@ impl EventLoop {
         Ok((event_loop, handle))
     }
 
-    pub async fn run(mut self) {
+    pub async fn run(mut self) -> Result<Infallible> {
         loop {
             tokio::select! {
                 swarm_event = self.swarm.next().fuse() => {
@@ -193,7 +193,7 @@ impl EventLoop {
                         }
                         OutEvent::ResponseSent => {}
                         OutEvent::CommunicationError(err) => {
-                            error!("Communication error: {:#}", err)
+                            bail!("Communication error: {:#}", err)
                         }
                     }
                 },

swap/tests/testutils/mod.rs

@@ -9,6 +9,7 @@ use get_port::get_port;
 use libp2p::{core::Multiaddr, PeerId};
 use monero_harness::{image, Monero};
 use std::{
+    convert::Infallible,
     path::{Path, PathBuf},
     sync::Arc,
     time::Duration,
@@ -67,7 +68,7 @@ impl BobParams {
     }
 }
 
-pub struct BobEventLoopJoinHandle(JoinHandle<()>);
+pub struct BobEventLoopJoinHandle(JoinHandle<Result<Infallible>>);
 
 impl BobEventLoopJoinHandle {
     pub fn abort(&self) {