mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-02-25 15:20:24 +01:00
Code Issues Projects Releases Packages Wiki Activity

Drop peers_needing_send tracking and try to write for each peer

Browse source 
We do a lot of work to track which peers have buffers which need
to be flushed, when we could instead just try to flush ever peer's
buffer.
This commit is contained in:
Matt Corallo 2021-06-10 18:46:24 +00:00
parent 0426d6e7a9
commit ae39b2ce19
1 changed files with 27 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

86
lightning/src/ln/peer_handler.rs
View file

@ -287,9 +287,6 @@ impl Peer {
struct PeerHolder<Descriptor: SocketDescriptor> { struct PeerHolder<Descriptor: SocketDescriptor> {
peers: HashMap<Descriptor, Peer>, peers: HashMap<Descriptor, Peer>,
/// Added to by do_read_event for cases where we pushed a message onto the send buffer but
/// didn't call do_attempt_write_data to avoid reentrancy. Cleared in process_events()
peers_needing_send: HashSet<Descriptor>,
/// Only add to this set when noise completes: /// Only add to this set when noise completes:
node_id_to_descriptor: HashMap<PublicKey, Descriptor>, node_id_to_descriptor: HashMap<PublicKey, Descriptor>,
} }
@ -420,7 +417,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
message_handler, message_handler,
peers: Mutex::new(PeerHolder { peers: Mutex::new(PeerHolder {
peers: HashMap::new(), peers: HashMap::new(),
peers_needing_send: HashSet::new(),
node_id_to_descriptor: HashMap::new() node_id_to_descriptor: HashMap::new()
}), }),
our_node_secret, our_node_secret,
@ -652,14 +648,13 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
} }
/// Append a message to a peer's pending outbound/write buffer, and update the map of peers needing sends accordingly. /// Append a message to a peer's pending outbound/write buffer, and update the map of peers needing sends accordingly.
fn enqueue_message<M: Encode + Writeable>(&self, peers_needing_send: &mut HashSet<Descriptor>, peer: &mut Peer, descriptor: Descriptor, message: &M) { fn enqueue_message<M: Encode + Writeable>(&self, peer: &mut Peer, message: &M) {
let mut buffer = VecWriter(Vec::new()); let mut buffer = VecWriter(Vec::new());
wire::write(message, &mut buffer).unwrap(); // crash if the write failed wire::write(message, &mut buffer).unwrap(); // crash if the write failed
let encoded_message = buffer.0; let encoded_message = buffer.0;
log_trace!(self.logger, "Enqueueing message of type {} to {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap())); log_trace!(self.logger, "Enqueueing message of type {} to {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_message[..])); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_message[..]));
peers_needing_send.insert(descriptor);
} }
fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: &[u8]) -> Result<bool, PeerHandleError> { fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: &[u8]) -> Result<bool, PeerHandleError> {
@ -703,7 +698,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
}, },
msgs::ErrorAction::SendErrorMessage { msg } => { msgs::ErrorAction::SendErrorMessage { msg } => {
log_trace!(self.logger, "Got Err handling message, sending Error message because {}", e.err); log_trace!(self.logger, "Got Err handling message, sending Error message because {}", e.err);
self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &msg); self.enqueue_message(peer, &msg);
continue; continue;
}, },
} }
@ -745,7 +740,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
insert_node_id!(); insert_node_id!();
let features = InitFeatures::known(); let features = InitFeatures::known();
let resp = msgs::Init { features }; let resp = msgs::Init { features };
self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp); self.enqueue_message(peer, &resp);
}, },
NextNoiseStep::ActThree => { NextNoiseStep::ActThree => {
let their_node_id = try_potential_handleerror!(peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..])); let their_node_id = try_potential_handleerror!(peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..]));
@ -755,7 +750,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
insert_node_id!(); insert_node_id!();
let features = InitFeatures::known(); let features = InitFeatures::known();
let resp = msgs::Init { features }; let resp = msgs::Init { features };
self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp); self.enqueue_message(peer, &resp);
}, },
NextNoiseStep::NoiseComplete => { NextNoiseStep::NoiseComplete => {
if peer.pending_read_is_header { if peer.pending_read_is_header {
@ -803,7 +798,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
} }
}; };
match self.handle_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), message) { match self.handle_message(peer, message) {
Err(handling_error) => match handling_error { Err(handling_error) => match handling_error {
MessageHandlingError::PeerHandleError(e) => { return Err(e) }, MessageHandlingError::PeerHandleError(e) => { return Err(e) },
MessageHandlingError::LightningError(e) => { MessageHandlingError::LightningError(e) => {
@ -838,7 +833,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
/// Process an incoming message and return a decision (ok, lightning error, peer handling error) regarding the next action with the peer /// Process an incoming message and return a decision (ok, lightning error, peer handling error) regarding the next action with the peer
/// Returns the message back if it needs to be broadcasted to all other peers. /// Returns the message back if it needs to be broadcasted to all other peers.
fn handle_message(&self, peers_needing_send: &mut HashSet<Descriptor>, peer: &mut Peer, peer_descriptor: Descriptor, message: wire::Message) -> Result<Option<wire::Message>, MessageHandlingError> { fn handle_message(&self, peer: &mut Peer, message: wire::Message) -> Result<Option<wire::Message>, MessageHandlingError> {
log_trace!(self.logger, "Received message of type {} from {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap())); log_trace!(self.logger, "Received message of type {} from {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
// Need an Init as first message // Need an Init as first message
@ -873,7 +868,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
if msg.features.initial_routing_sync() { if msg.features.initial_routing_sync() {
peer.sync_status = InitSyncTracker::ChannelsSyncing(0); peer.sync_status = InitSyncTracker::ChannelsSyncing(0);
peers_needing_send.insert(peer_descriptor.clone());
} }
if !msg.features.supports_static_remote_key() { if !msg.features.supports_static_remote_key() {
log_debug!(self.logger, "Peer {} does not support static remote key, disconnecting with no_connection_possible", log_pubkey!(peer.their_node_id.unwrap())); log_debug!(self.logger, "Peer {} does not support static remote key, disconnecting with no_connection_possible", log_pubkey!(peer.their_node_id.unwrap()));
@ -908,7 +902,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
wire::Message::Ping(msg) => { wire::Message::Ping(msg) => {
if msg.ponglen < 65532 { if msg.ponglen < 65532 {
let resp = msgs::Pong { byteslen: msg.ponglen }; let resp = msgs::Pong { byteslen: msg.ponglen };
self.enqueue_message(peers_needing_send, peer, peer_descriptor.clone(), &resp); self.enqueue_message(peer, &resp);
} }
}, },
wire::Message::Pong(_msg) => { wire::Message::Pong(_msg) => {
@ -1030,7 +1024,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
wire::Message::ChannelAnnouncement(ref msg) => { wire::Message::ChannelAnnouncement(ref msg) => {
let encoded_msg = encode_msg!(msg); let encoded_msg = encode_msg!(msg);
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { for (_, peer) in peers.peers.iter_mut() {
if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
!peer.should_forward_channel_announcement(msg.contents.short_channel_id) { !peer.should_forward_channel_announcement(msg.contents.short_channel_id) {
continue continue
@ -1046,13 +1040,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
continue; continue;
} }
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
peers.peers_needing_send.insert((*descriptor).clone());
} }
}, },
wire::Message::NodeAnnouncement(ref msg) => { wire::Message::NodeAnnouncement(ref msg) => {
let encoded_msg = encode_msg!(msg); let encoded_msg = encode_msg!(msg);
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { for (_, peer) in peers.peers.iter_mut() {
if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
!peer.should_forward_node_announcement(msg.contents.node_id) { !peer.should_forward_node_announcement(msg.contents.node_id) {
continue continue
@ -1067,13 +1060,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
continue; continue;
} }
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
peers.peers_needing_send.insert((*descriptor).clone());
} }
}, },
wire::Message::ChannelUpdate(ref msg) => { wire::Message::ChannelUpdate(ref msg) => {
let encoded_msg = encode_msg!(msg); let encoded_msg = encode_msg!(msg);
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { for (_, peer) in peers.peers.iter_mut() {
if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
!peer.should_forward_channel_announcement(msg.contents.short_channel_id) { !peer.should_forward_channel_announcement(msg.contents.short_channel_id) {
continue continue
@ -1085,7 +1077,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
continue; continue;
} }
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
peers.peers_needing_send.insert((*descriptor).clone());
} }
}, },
_ => debug_assert!(false, "We shouldn't attempt to forward anything but gossip messages"), _ => debug_assert!(false, "We shouldn't attempt to forward anything but gossip messages"),
@ -1132,17 +1123,15 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
log_trace!(self.logger, "Handling SendAcceptChannel event in peer_handler for node {} for channel {}", log_trace!(self.logger, "Handling SendAcceptChannel event in peer_handler for node {} for channel {}",
log_pubkey!(node_id), log_pubkey!(node_id),
log_bytes!(msg.temporary_channel_id)); log_bytes!(msg.temporary_channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendOpenChannel { ref node_id, ref msg } => { MessageSendEvent::SendOpenChannel { ref node_id, ref msg } => {
log_trace!(self.logger, "Handling SendOpenChannel event in peer_handler for node {} for channel {}", log_trace!(self.logger, "Handling SendOpenChannel event in peer_handler for node {} for channel {}",
log_pubkey!(node_id), log_pubkey!(node_id),
log_bytes!(msg.temporary_channel_id)); log_bytes!(msg.temporary_channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendFundingCreated { ref node_id, ref msg } => { MessageSendEvent::SendFundingCreated { ref node_id, ref msg } => {
log_trace!(self.logger, "Handling SendFundingCreated event in peer_handler for node {} for channel {} (which becomes {})", log_trace!(self.logger, "Handling SendFundingCreated event in peer_handler for node {} for channel {} (which becomes {})",
@ -1151,33 +1140,29 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
log_funding_channel_id!(msg.funding_txid, msg.funding_output_index)); log_funding_channel_id!(msg.funding_txid, msg.funding_output_index));
// TODO: If the peer is gone we should generate a DiscardFunding event // TODO: If the peer is gone we should generate a DiscardFunding event
// indicating to the wallet that they should just throw away this funding transaction // indicating to the wallet that they should just throw away this funding transaction
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendFundingSigned { ref node_id, ref msg } => { MessageSendEvent::SendFundingSigned { ref node_id, ref msg } => {
log_trace!(self.logger, "Handling SendFundingSigned event in peer_handler for node {} for channel {}", log_trace!(self.logger, "Handling SendFundingSigned event in peer_handler for node {} for channel {}",
log_pubkey!(node_id), log_pubkey!(node_id),
log_bytes!(msg.channel_id)); log_bytes!(msg.channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => { MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
log_trace!(self.logger, "Handling SendFundingLocked event in peer_handler for node {} for channel {}", log_trace!(self.logger, "Handling SendFundingLocked event in peer_handler for node {} for channel {}",
log_pubkey!(node_id), log_pubkey!(node_id),
log_bytes!(msg.channel_id)); log_bytes!(msg.channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => { MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
log_trace!(self.logger, "Handling SendAnnouncementSignatures event in peer_handler for node {} for channel {})", log_trace!(self.logger, "Handling SendAnnouncementSignatures event in peer_handler for node {} for channel {})",
log_pubkey!(node_id), log_pubkey!(node_id),
log_bytes!(msg.channel_id)); log_bytes!(msg.channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => { MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => {
log_trace!(self.logger, "Handling UpdateHTLCs event in peer_handler for node {} with {} adds, {} fulfills, {} fails for channel {}", log_trace!(self.logger, "Handling UpdateHTLCs event in peer_handler for node {} with {} adds, {} fulfills, {} fails for channel {}",
@ -1186,7 +1171,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
update_fulfill_htlcs.len(), update_fulfill_htlcs.len(),
update_fail_htlcs.len(), update_fail_htlcs.len(),
log_bytes!(commitment_signed.channel_id)); log_bytes!(commitment_signed.channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
for msg in update_add_htlcs { for msg in update_add_htlcs {
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
} }
@ -1203,39 +1188,34 @@ 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))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
} }
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(commitment_signed))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(commitment_signed)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
log_trace!(self.logger, "Handling SendRevokeAndACK event in peer_handler for node {} for channel {}", log_trace!(self.logger, "Handling SendRevokeAndACK event in peer_handler for node {} for channel {}",
log_pubkey!(node_id), log_pubkey!(node_id),
log_bytes!(msg.channel_id)); log_bytes!(msg.channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => { MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
log_trace!(self.logger, "Handling SendClosingSigned event in peer_handler for node {} for channel {}", log_trace!(self.logger, "Handling SendClosingSigned event in peer_handler for node {} for channel {}",
log_pubkey!(node_id), log_pubkey!(node_id),
log_bytes!(msg.channel_id)); log_bytes!(msg.channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendShutdown { ref node_id, ref msg } => { MessageSendEvent::SendShutdown { ref node_id, ref msg } => {
log_trace!(self.logger, "Handling Shutdown event in peer_handler for node {} for channel {}", log_trace!(self.logger, "Handling Shutdown event in peer_handler for node {} for channel {}",
log_pubkey!(node_id), log_pubkey!(node_id),
log_bytes!(msg.channel_id)); log_bytes!(msg.channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } => { MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } => {
log_trace!(self.logger, "Handling SendChannelReestablish event in peer_handler for node {} for channel {}", log_trace!(self.logger, "Handling SendChannelReestablish event in peer_handler for node {} for channel {}",
log_pubkey!(node_id), log_pubkey!(node_id),
log_bytes!(msg.channel_id)); log_bytes!(msg.channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::BroadcastChannelAnnouncement { msg, update_msg } => { MessageSendEvent::BroadcastChannelAnnouncement { msg, update_msg } => {
log_trace!(self.logger, "Handling BroadcastChannelAnnouncement event in peer_handler for short channel id {}", msg.contents.short_channel_id); log_trace!(self.logger, "Handling BroadcastChannelAnnouncement event in peer_handler for short channel id {}", msg.contents.short_channel_id);
@ -1263,7 +1243,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
match *action { match *action {
msgs::ErrorAction::DisconnectPeer { ref msg } => { msgs::ErrorAction::DisconnectPeer { ref msg } => {
if let Some(mut descriptor) = peers.node_id_to_descriptor.remove(node_id) { if let Some(mut descriptor) = peers.node_id_to_descriptor.remove(node_id) {
peers.peers_needing_send.remove(&descriptor);
if let Some(mut peer) = peers.peers.remove(&descriptor) { if let Some(mut peer) = peers.peers.remove(&descriptor) {
if let Some(ref msg) = *msg { if let Some(ref msg) = *msg {
log_trace!(self.logger, "Handling DisconnectPeer HandleError event in peer_handler for node {} with message {}", log_trace!(self.logger, "Handling DisconnectPeer HandleError event in peer_handler for node {} with message {}",
@ -1286,21 +1265,18 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
log_trace!(self.logger, "Handling SendErrorMessage HandleError event in peer_handler for node {} with message {}", log_trace!(self.logger, "Handling SendErrorMessage HandleError event in peer_handler for node {} with message {}",
log_pubkey!(node_id), log_pubkey!(node_id),
msg.data); msg.data);
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
} }
}, },
MessageSendEvent::SendChannelRangeQuery { ref node_id, ref msg } => { MessageSendEvent::SendChannelRangeQuery { ref node_id, ref msg } => {
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
}, },
MessageSendEvent::SendShortIdsQuery { ref node_id, ref msg } => { MessageSendEvent::SendShortIdsQuery { ref node_id, ref msg } => {
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); 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 } => { 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_trace!(self.logger, "Handling SendReplyChannelRange event in peer_handler for node {} with num_scids={} first_blocknum={} number_of_blocks={}, sync_complete={}",
@ -1309,18 +1285,14 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
msg.first_blocknum, msg.first_blocknum,
msg.number_of_blocks, msg.number_of_blocks,
msg.sync_complete); msg.sync_complete);
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); let (_, peer) = get_peer_for_forwarding!(node_id);
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
self.do_attempt_write_data(&mut descriptor, peer);
} }
} }
} }
for mut descriptor in peers.peers_needing_send.drain() { for (descriptor, peer) in peers.peers.iter_mut() {
match peers.peers.get_mut(&descriptor) { self.do_attempt_write_data(&mut (*descriptor).clone(), peer);
Some(peer) => self.do_attempt_write_data(&mut descriptor, peer),
None => panic!("Inconsistent peers set state!"),
}
} }
} }
} }
@ -1339,7 +1311,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
fn disconnect_event_internal(&self, descriptor: &Descriptor, no_connection_possible: bool) { fn disconnect_event_internal(&self, descriptor: &Descriptor, no_connection_possible: bool) {
let mut peers = self.peers.lock().unwrap(); let mut peers = self.peers.lock().unwrap();
peers.peers_needing_send.remove(descriptor);
let peer_option = peers.peers.remove(descriptor); let peer_option = peers.peers.remove(descriptor);
match peer_option { match peer_option {
None => panic!("Descriptor for disconnect_event is not already known to PeerManager"), None => panic!("Descriptor for disconnect_event is not already known to PeerManager"),
@ -1367,7 +1338,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
if let Some(mut descriptor) = peers_lock.node_id_to_descriptor.remove(&node_id) { if let Some(mut descriptor) = peers_lock.node_id_to_descriptor.remove(&node_id) {
log_trace!(self.logger, "Disconnecting peer with id {} due to client request", node_id); log_trace!(self.logger, "Disconnecting peer with id {} due to client request", node_id);
peers_lock.peers.remove(&descriptor); peers_lock.peers.remove(&descriptor);
peers_lock.peers_needing_send.remove(&descriptor);
self.message_handler.chan_handler.peer_disconnected(&node_id, no_connection_possible); self.message_handler.chan_handler.peer_disconnected(&node_id, no_connection_possible);
descriptor.disconnect_socket(); descriptor.disconnect_socket();
} }
@ -1381,14 +1351,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
let mut peers_lock = self.peers.lock().unwrap(); let mut peers_lock = self.peers.lock().unwrap();
{ {
let peers = &mut *peers_lock; let peers = &mut *peers_lock;
let peers_needing_send = &mut peers.peers_needing_send;
let node_id_to_descriptor = &mut peers.node_id_to_descriptor; let node_id_to_descriptor = &mut peers.node_id_to_descriptor;
let peers = &mut peers.peers; let peers = &mut peers.peers;
let mut descriptors_needing_disconnect = Vec::new(); let mut descriptors_needing_disconnect = Vec::new();
peers.retain(|descriptor, peer| { peers.retain(|descriptor, peer| {
if peer.awaiting_pong { if peer.awaiting_pong {
peers_needing_send.remove(descriptor);
descriptors_needing_disconnect.push(descriptor.clone()); descriptors_needing_disconnect.push(descriptor.clone());
match peer.their_node_id { match peer.their_node_id {
Some(node_id) => { Some(node_id) => {