use std::io::Write;
use std::ops::Deref;
use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime};
let peer_manager_connection_handler = peer_manager.clone();
let listening_port = args.ldk_peer_listening_port;
+ let stop_listen_connect = Arc::new(AtomicBool::new(false));
+ let stop_listen = Arc::clone(&stop_listen_connect);
tokio::spawn(async move {
let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", listening_port))
.await
loop {
let peer_mgr = peer_manager_connection_handler.clone();
let tcp_stream = listener.accept().await.unwrap().0;
+ if stop_listen.load(Ordering::Acquire) {
+ return;
+ }
tokio::spawn(async move {
lightning_net_tokio::setup_inbound(
peer_mgr.clone(),
let connect_cm = Arc::clone(&channel_manager);
let connect_pm = Arc::clone(&peer_manager);
let peer_data_path = format!("{}/channel_peer_data", ldk_data_dir.clone());
+ let stop_connect = Arc::clone(&stop_listen_connect);
tokio::spawn(async move {
let mut interval = tokio::time::interval(Duration::from_secs(1));
loop {
.map(|chan| chan.counterparty.node_id)
.filter(|id| !peers.contains(id))
{
+ if stop_connect.load(Ordering::Acquire) {
+ return;
+ }
for (pubkey, peer_addr) in info.iter() {
if *pubkey == node_id {
let _ = cli::do_connect_peer(
// Start the CLI.
cli::poll_for_user_input(
- invoice_payer.clone(),
- peer_manager.clone(),
- channel_manager.clone(),
- keys_manager.clone(),
+ Arc::clone(&invoice_payer),
+ Arc::clone(&peer_manager),
+ Arc::clone(&channel_manager),
+ Arc::clone(&keys_manager),
+ Arc::clone(&network_graph),
inbound_payments,
outbound_payments,
ldk_data_dir.clone(),
)
.await;
+ // Disconnect our peers and stop accepting new connections. This ensures we don't continue
+ // updating our channel data after we've stopped the background processor.
+ stop_listen_connect.store(true, Ordering::Release);
+ peer_manager.disconnect_all_peers();
+
// Stop the background processor.
background_processor.stop().unwrap();
}