X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;ds=sidebyside;f=lightning-net-tokio%2Fsrc%2Flib.rs;h=36384380fb14a458b31e132446ae374ffaf0b51d;hb=90b668e426ab0a9867458369c9b4739e77f3596d;hp=e635d93d383162560ad28060de65dd5a361dd902;hpb=60d37b2698e5cb3744263ecc95c68bb2dee93ea4;p=rust-lightning diff --git a/lightning-net-tokio/src/lib.rs b/lightning-net-tokio/src/lib.rs index e635d93d..36384380 100644 --- a/lightning-net-tokio/src/lib.rs +++ b/lightning-net-tokio/src/lib.rs @@ -1,3 +1,12 @@ +// This file is Copyright its original authors, visible in version control +// history. +// +// This file is licensed under the Apache License, Version 2.0 or the MIT license +// , at your option. +// You may not use this file except in accordance with one or both of these +// licenses. + //! A socket handling library for those running in Tokio environments who wish to use //! rust-lightning with native TcpStreams. //! @@ -16,7 +25,7 @@ //! ``` //! use tokio::sync::mpsc; //! use tokio::net::TcpStream; -//! use secp256k1::key::PublicKey; +//! use bitcoin::secp256k1::key::PublicKey; //! use lightning::util::events::EventsProvider; //! use std::net::SocketAddr; //! use std::sync::Arc; @@ -24,12 +33,16 @@ //! // Define concrete types for our high-level objects: //! type TxBroadcaster = dyn lightning::chain::chaininterface::BroadcasterInterface; //! type FeeEstimator = dyn lightning::chain::chaininterface::FeeEstimator; -//! type ChannelMonitor = lightning::ln::channelmonitor::SimpleManyChannelMonitor, Arc>; -//! type ChannelManager = lightning::ln::channelmanager::SimpleArcChannelManager; -//! type PeerManager = lightning::ln::peer_handler::SimpleArcPeerManager; +//! type Logger = dyn lightning::util::logger::Logger; +//! type ChainAccess = dyn lightning::chain::Access; +//! type ChainFilter = dyn lightning::chain::Filter; +//! type DataPersister = dyn lightning::chain::channelmonitor::Persist; +//! type ChainMonitor = lightning::chain::chainmonitor::ChainMonitor, Arc, Arc, Arc, Arc>; +//! type ChannelManager = lightning::ln::channelmanager::SimpleArcChannelManager; +//! type PeerManager = lightning::ln::peer_handler::SimpleArcPeerManager; //! //! // Connect to node with pubkey their_node_id at addr: -//! async fn connect_to_node(peer_manager: PeerManager, channel_monitor: Arc, channel_manager: ChannelManager, their_node_id: PublicKey, addr: SocketAddr) { +//! async fn connect_to_node(peer_manager: PeerManager, chain_monitor: Arc, channel_manager: ChannelManager, their_node_id: PublicKey, addr: SocketAddr) { //! let (sender, mut receiver) = mpsc::channel(2); //! lightning_net_tokio::connect_outbound(peer_manager, sender, their_node_id, addr).await; //! loop { @@ -37,14 +50,14 @@ //! for _event in channel_manager.get_and_clear_pending_events().drain(..) { //! // Handle the event! //! } -//! for _event in channel_monitor.get_and_clear_pending_events().drain(..) { +//! for _event in chain_monitor.get_and_clear_pending_events().drain(..) { //! // Handle the event! //! } //! } //! } //! //! // Begin reading from a newly accepted socket and talk to the peer: -//! async fn accept_socket(peer_manager: PeerManager, channel_monitor: Arc, channel_manager: ChannelManager, socket: TcpStream) { +//! async fn accept_socket(peer_manager: PeerManager, chain_monitor: Arc, channel_manager: ChannelManager, socket: TcpStream) { //! let (sender, mut receiver) = mpsc::channel(2); //! lightning_net_tokio::setup_inbound(peer_manager, sender, socket); //! loop { @@ -52,14 +65,14 @@ //! for _event in channel_manager.get_and_clear_pending_events().drain(..) { //! // Handle the event! //! } -//! for _event in channel_monitor.get_and_clear_pending_events().drain(..) { +//! for _event in chain_monitor.get_and_clear_pending_events().drain(..) { //! // Handle the event! //! } //! } //! } //! ``` -use secp256k1::key::PublicKey; +use bitcoin::secp256k1::key::PublicKey; use tokio::net::TcpStream; use tokio::{io, time}; @@ -68,7 +81,8 @@ use tokio::io::{AsyncReadExt, AsyncWrite, AsyncWriteExt}; use lightning::ln::peer_handler; use lightning::ln::peer_handler::SocketDescriptor as LnSocketTrait; -use lightning::ln::msgs::ChannelMessageHandler; +use lightning::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler}; +use lightning::util::logger::Logger; use std::{task, thread}; use std::net::SocketAddr; @@ -87,7 +101,7 @@ struct Connection { event_notify: mpsc::Sender<()>, // Because our PeerManager is templated by user-provided types, and we can't (as far as I can // tell) have a const RawWakerVTable built out of templated functions, we need some indirection - // between being woken up with write-ready and calling PeerManager::write_buffer_spce_avail. + // between being woken up with write-ready and calling PeerManager::write_buffer_space_avail. // This provides that indirection, with a Sender which gets handed to the PeerManager Arc on // the schedule_read stack. // @@ -121,7 +135,10 @@ impl Connection { _ => panic!() } } - async fn schedule_read(peer_manager: Arc>>, us: Arc>, mut reader: io::ReadHalf, mut read_wake_receiver: mpsc::Receiver<()>, mut write_avail_receiver: mpsc::Receiver<()>) { + async fn schedule_read(peer_manager: Arc, Arc, Arc>>, us: Arc>, mut reader: io::ReadHalf, mut read_wake_receiver: mpsc::Receiver<()>, mut write_avail_receiver: mpsc::Receiver<()>) where + CMH: ChannelMessageHandler + 'static, + RMH: RoutingMessageHandler + 'static, + L: Logger + 'static + ?Sized { let peer_manager_ref = peer_manager.clone(); // 8KB is nice and big but also should never cause any issues with stack overflowing. let mut buf = [0; 8192]; @@ -231,7 +248,10 @@ impl Connection { /// not need to poll the provided future in order to make progress. /// /// See the module-level documentation for how to handle the event_notify mpsc::Sender. -pub fn setup_inbound(peer_manager: Arc>>, event_notify: mpsc::Sender<()>, stream: TcpStream) -> impl std::future::Future { +pub fn setup_inbound(peer_manager: Arc, Arc, Arc>>, event_notify: mpsc::Sender<()>, stream: TcpStream) -> impl std::future::Future where + CMH: ChannelMessageHandler + 'static, + RMH: RoutingMessageHandler + 'static, + L: Logger + 'static + ?Sized { let (reader, write_receiver, read_receiver, us) = Connection::new(event_notify, stream); #[cfg(debug_assertions)] let last_us = Arc::clone(&us); @@ -270,19 +290,39 @@ pub fn setup_inbound(peer_manager: Arc(peer_manager: Arc>>, event_notify: mpsc::Sender<()>, their_node_id: PublicKey, stream: TcpStream) -> impl std::future::Future { - let (reader, write_receiver, read_receiver, us) = Connection::new(event_notify, stream); +pub fn setup_outbound(peer_manager: Arc, Arc, Arc>>, event_notify: mpsc::Sender<()>, their_node_id: PublicKey, stream: TcpStream) -> impl std::future::Future where + CMH: ChannelMessageHandler + 'static, + RMH: RoutingMessageHandler + 'static, + L: Logger + 'static + ?Sized { + let (reader, mut write_receiver, read_receiver, us) = Connection::new(event_notify, stream); #[cfg(debug_assertions)] let last_us = Arc::clone(&us); let handle_opt = if let Ok(initial_send) = peer_manager.new_outbound_connection(their_node_id, SocketDescriptor::new(us.clone())) { Some(tokio::spawn(async move { - if SocketDescriptor::new(us.clone()).send_data(&initial_send, true) != initial_send.len() { - // We should essentially always have enough room in a TCP socket buffer to send the - // initial 10s of bytes, if not, just give up as hopeless. - eprintln!("Failed to write first full message to socket!"); - peer_manager.socket_disconnected(&SocketDescriptor::new(Arc::clone(&us))); - } else { + // We should essentially always have enough room in a TCP socket buffer to send the + // initial 10s of bytes. However, tokio running in single-threaded mode will always + // fail writes and wake us back up later to write. Thus, we handle a single + // std::task::Poll::Pending but still expect to write the full set of bytes at once + // and use a relatively tight timeout. + if let Ok(Ok(())) = tokio::time::timeout(Duration::from_millis(100), async { + loop { + match SocketDescriptor::new(us.clone()).send_data(&initial_send, true) { + v if v == initial_send.len() => break Ok(()), + 0 => { + write_receiver.recv().await; + // In theory we could check for if we've been instructed to disconnect + // the peer here, but its OK to just skip it - we'll check for it in + // schedule_read prior to any relevant calls into RL. + }, + _ => { + eprintln!("Failed to write first full message to socket!"); + peer_manager.socket_disconnected(&SocketDescriptor::new(Arc::clone(&us))); + break Err(()); + } + } + } + }).await { Connection::schedule_read(peer_manager, us, reader, read_receiver, write_receiver).await; } })) @@ -322,7 +362,10 @@ pub fn setup_outbound(peer_manager: Arc(peer_manager: Arc>>, event_notify: mpsc::Sender<()>, their_node_id: PublicKey, addr: SocketAddr) -> Option> { +pub async fn connect_outbound(peer_manager: Arc, Arc, Arc>>, event_notify: mpsc::Sender<()>, their_node_id: PublicKey, addr: SocketAddr) -> Option> where + CMH: ChannelMessageHandler + 'static, + RMH: RoutingMessageHandler + 'static, + L: Logger + 'static + ?Sized { if let Ok(Ok(stream)) = time::timeout(Duration::from_secs(10), TcpStream::connect(&addr)).await { Some(setup_outbound(peer_manager, event_notify, their_node_id, stream)) } else { None } @@ -464,7 +507,7 @@ mod tests { use lightning::ln::msgs::*; use lightning::ln::peer_handler::{MessageHandler, PeerManager}; use lightning::util::events::*; - use secp256k1::{Secp256k1, SecretKey, PublicKey}; + use bitcoin::secp256k1::{Secp256k1, SecretKey, PublicKey}; use tokio::sync::mpsc; @@ -490,7 +533,7 @@ mod tests { fn handle_channel_announcement(&self, _msg: &ChannelAnnouncement) -> Result { Ok(false) } fn handle_channel_update(&self, _msg: &ChannelUpdate) -> Result { Ok(false) } fn handle_htlc_fail_channel_update(&self, _update: &HTLCFailChannelUpdate) { } - fn get_next_channel_announcements(&self, _starting_point: u64, _batch_amount: u8) -> Vec<(ChannelAnnouncement, ChannelUpdate, ChannelUpdate)> { Vec::new() } + fn get_next_channel_announcements(&self, _starting_point: u64, _batch_amount: u8) -> Vec<(ChannelAnnouncement, Option, Option)> { Vec::new() } fn get_next_node_announcements(&self, _starting_point: Option<&PublicKey>, _batch_amount: u8) -> Vec { Vec::new() } fn should_request_full_sync(&self, _node_id: &PublicKey) -> bool { false } } @@ -531,8 +574,7 @@ mod tests { } } - #[tokio::test(threaded_scheduler)] - async fn basic_connection_test() { + async fn do_basic_connection_test() { let secp_ctx = Secp256k1::new(); let a_key = SecretKey::from_slice(&[1; 32]).unwrap(); let b_key = SecretKey::from_slice(&[1; 32]).unwrap(); @@ -549,7 +591,7 @@ mod tests { }); let a_manager = Arc::new(PeerManager::new(MessageHandler { chan_handler: Arc::clone(&a_handler), - route_handler: Arc::clone(&a_handler) as Arc, + route_handler: Arc::clone(&a_handler), }, a_key.clone(), &[1; 32], Arc::new(TestLogger()))); let (b_connected_sender, mut b_connected) = mpsc::channel(1); @@ -562,7 +604,7 @@ mod tests { }); let b_manager = Arc::new(PeerManager::new(MessageHandler { chan_handler: Arc::clone(&b_handler), - route_handler: Arc::clone(&b_handler) as Arc, + route_handler: Arc::clone(&b_handler), }, b_key.clone(), &[2; 32], Arc::new(TestLogger()))); // We bind on localhost, hoping the environment is properly configured with a local @@ -597,4 +639,13 @@ mod tests { fut_a.await; fut_b.await; } + + #[tokio::test(threaded_scheduler)] + async fn basic_threaded_connection_test() { + do_basic_connection_test().await; + } + #[tokio::test] + async fn basic_unthreaded_connection_test() { + do_basic_connection_test().await; + } }