Explicitly stop BackgroundProcessor

[ldk-sample] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index a8b28f57d12b5056df3031f88dbcf0fdae31cabb..7c1a1034262b5460a4340eaedc396d0c88885b47 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -19,11 +19,10 @@ use lightning::chain;
 use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator};
 use lightning::chain::chainmonitor;
 use lightning::chain::keysinterface::{InMemorySigner, KeysInterface, KeysManager};
-use lightning::chain::Filter;
-use lightning::chain::Watch;
+use lightning::chain::{BestBlock, Filter, Watch};
 use lightning::ln::channelmanager;
 use lightning::ln::channelmanager::{
-       BestBlock, ChainParameters, ChannelManagerReadArgs, SimpleArcChannelManager,
+       ChainParameters, ChannelManagerReadArgs, SimpleArcChannelManager,
 };
 use lightning::ln::peer_handler::{MessageHandler, SimpleArcPeerManager};
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -426,13 +425,33 @@ async fn start_ldk() {
        }
 
        // Step 11: Optional: Initialize the NetGraphMsgHandler
-       // XXX persist routing data
        let genesis = genesis_block(args.network).header.block_hash();
-       let router = Arc::new(NetGraphMsgHandler::new(
-               genesis,
+       let network_graph_path = format!("{}/network_graph", ldk_data_dir.clone());
+       let network_graph = disk::read_network(Path::new(&network_graph_path), genesis);
+       let router = Arc::new(NetGraphMsgHandler::from_net_graph(
                None::<Arc<dyn chain::Access + Send + Sync>>,
                logger.clone(),
+               network_graph,
        ));
+       let router_persist = Arc::clone(&router);
+       tokio::spawn(async move {
+               let mut interval = tokio::time::interval(Duration::from_secs(600));
+               loop {
+                       interval.tick().await;
+                       if disk::persist_network(
+                               Path::new(&network_graph_path),
+                               &*router_persist.network_graph.read().unwrap(),
+                       )
+                       .is_err()
+                       {
+                               // Persistence errors here are non-fatal as we can just fetch the routing graph
+                               // again later, but they may indicate a disk error which could be fatal elsewhere.
+                               eprintln!(
+                                       "Warning: Failed to persist network graph, check your disk and permissions"
+                               );
+                       }
+               }
+       });
 
        // Step 12: Initialize the PeerManager
        let channel_manager: Arc<ChannelManager> = Arc::new(channel_manager);
@@ -490,7 +509,7 @@ async fn start_ldk() {
                }
        });
 
-       // Step 15: Event Handling
+       // Step 15: Handle LDK Events
        let channel_manager_event_listener = channel_manager.clone();
        let keys_manager_listener = keys_manager.clone();
        // TODO: persist payment info to disk
@@ -512,12 +531,12 @@ async fn start_ldk() {
                        event,
                ))
        };
-       // Step 16: ChannelManager Persisting
+       // Step 16: Persist ChannelManager
        let data_dir = ldk_data_dir.clone();
        let persist_channel_manager_callback =
                move |node: &ChannelManager| FilesystemPersister::persist_manager(data_dir.clone(), &*node);
        // Step 17: Background Processing
-       BackgroundProcessor::start(
+       let background_processor = BackgroundProcessor::start(
                persist_channel_manager_callback,
                event_handler,
                chain_monitor.clone(),
@@ -532,7 +551,7 @@ async fn start_ldk() {
                Ok(mut info) => {
                        for (pubkey, peer_addr) in info.drain() {
                                for chan_info in channel_manager.list_channels() {
-                                       if pubkey == chan_info.remote_network_id {
+                                       if pubkey == chan_info.counterparty.node_id {
                                                let _ =
                                                        cli::connect_peer_if_necessary(pubkey, peer_addr, peer_manager.clone())
                                                                .await;
@@ -576,6 +595,9 @@ async fn start_ldk() {
                network,
        )
        .await;
+
+       // Stop the background processor.
+       background_processor.stop().unwrap();
 }
 
 #[tokio::main]