Merge pull request #828 from bmancini55/reply_channel_range

[rust-lightning] / lightning / src / ln / peer_handler.rs

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index d37476327ba02750a34f2fa0e8a8bce0dc62a167..0e3f0ed4602a164a30189bc5ba0617f9be3451e1 100644 (file)
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -42,7 +42,7 @@ use bitcoin::hashes::{HashEngine, Hash};
 
 /// A dummy struct which implements `RoutingMessageHandler` without storing any routing information
 /// or doing any processing. You can provide one of these as the route_handler in a MessageHandler.
-struct IgnoringMessageHandler{}
+pub struct IgnoringMessageHandler{}
 impl MessageSendEventsProvider for IgnoringMessageHandler {
        fn get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent> { Vec::new() }
 }
@@ -67,7 +67,7 @@ impl Deref for IgnoringMessageHandler {
 
 /// A dummy struct which implements `ChannelMessageHandler` without having any channels.
 /// You can provide one of these as the route_handler in a MessageHandler.
-struct ErroringMessageHandler {
+pub struct ErroringMessageHandler {
        message_queue: Mutex<Vec<MessageSendEvent>>
 }
 impl ErroringMessageHandler {
@@ -1281,6 +1281,17 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
                                                peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
                                                self.do_attempt_write_data(&mut descriptor, peer);
                                        }
+                                       MessageSendEvent::SendReplyChannelRange { ref node_id, ref msg } => {
+                                               log_trace!(self.logger, "Handling SendReplyChannelRange event in peer_handler for node {} with num_scids={} first_blocknum={} number_of_blocks={}, sync_complete={}",
+                                                       log_pubkey!(node_id),
+                                                       msg.short_channel_ids.len(),
+                                                       msg.first_blocknum,
+                                                       msg.number_of_blocks,
+                                                       msg.sync_complete);
+                                               let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, {});
+                                               peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
+                                               self.do_attempt_write_data(&mut descriptor, peer);
+                                       }
                                }
                        }
 
@@ -1345,7 +1356,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
        /// It will send pings to each peer and disconnect those which did not respond to the last round of pings.
 
        /// Will most likely call send_data on all of the registered descriptors, thus, be very careful with reentrancy issues!
-       pub fn timer_tick_occured(&self) {
+       pub fn timer_tick_occurred(&self) {
                let mut peers_lock = self.peers.lock().unwrap();
                {
                        let peers = &mut *peers_lock;
@@ -1518,11 +1529,11 @@ mod tests {
                assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1);
 
                // peers[0] awaiting_pong is set to true, but the Peer is still connected
-               peers[0].timer_tick_occured();
+               peers[0].timer_tick_occurred();
                assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1);
 
-               // Since timer_tick_occured() is called again when awaiting_pong is true, all Peers are disconnected
-               peers[0].timer_tick_occured();
+               // Since timer_tick_occurred() is called again when awaiting_pong is true, all Peers are disconnected
+               peers[0].timer_tick_occurred();
                assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 0);
        }