Auto-reconnect peers every second

[ldk-sample] / src / cli.rs

diff --git a/src/cli.rs b/src/cli.rs
index 197c0ecf607a763f88873099d44da96982bd188f..d34512c56e3dc31b52b9e95f7d8bccb99d7583ce 100644 (file)
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -388,8 +388,14 @@ fn help() {
 fn node_info(channel_manager: Arc<ChannelManager>, peer_manager: Arc<PeerManager>) {
        println!("\t{{");
        println!("\t\t node_pubkey: {}", channel_manager.get_our_node_id());
-       println!("\t\t num_channels: {}", channel_manager.list_channels().len());
-       println!("\t\t num_usable_channels: {}", channel_manager.list_usable_channels().len());
+       let chans = channel_manager.list_channels();
+       println!("\t\t num_channels: {}", chans.len());
+       println!("\t\t num_usable_channels: {}", chans.iter().filter(|c| c.is_usable).count());
+       let local_balance_msat = chans
+               .iter()
+               .map(|c| c.unspendable_punishment_reserve.unwrap_or(0) * 1000 + c.outbound_capacity_msat)
+               .sum::<u64>();
+       println!("\t\t local_balance_msat: {}", local_balance_msat);
        println!("\t\t num_peers: {}", peer_manager.get_peer_node_ids().len());
        println!("\t}},");
 }
@@ -486,6 +492,16 @@ pub(crate) async fn connect_peer_if_necessary(
                        return Ok(());
                }
        }
+       let res = do_connect_peer(pubkey, peer_addr, peer_manager).await;
+       if res.is_err() {
+               println!("ERROR: failed to connect to peer");
+       }
+       res
+}
+
+pub(crate) async fn do_connect_peer(
+       pubkey: PublicKey, peer_addr: SocketAddr, peer_manager: Arc<PeerManager>,
+) -> Result<(), ()> {
        match lightning_net_tokio::connect_outbound(Arc::clone(&peer_manager), pubkey, peer_addr).await
        {
                Some(connection_closed_future) => {
@@ -493,24 +509,19 @@ pub(crate) async fn connect_peer_if_necessary(
                        loop {
                                match futures::poll!(&mut connection_closed_future) {
                                        std::task::Poll::Ready(_) => {
-                                               println!("ERROR: Peer disconnected before we finished the handshake");
                                                return Err(());
                                        }
                                        std::task::Poll::Pending => {}
                                }
                                // Avoid blocking the tokio context by sleeping a bit
                                match peer_manager.get_peer_node_ids().iter().find(|id| **id == pubkey) {
-                                       Some(_) => break,
+                                       Some(_) => return Ok(()),
                                        None => tokio::time::sleep(Duration::from_millis(10)).await,
                                }
                        }
                }
-               None => {
-                       println!("ERROR: failed to connect to peer");
-                       return Err(());
-               }
+               None => Err(()),
        }
-       Ok(())
 }
 
 fn open_channel(