Skip to content

Commit 41bb42a

Browse files
TheBlueMattTheBlueMatt
committed
Drop peers_needing_send tracking and try to write for each peer
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.
1 parent a6fcb74 commit 41bb42a

File tree

1 file changed

+28
-60
lines changed

1 file changed

+28
-60
lines changed

‎lightning/src/ln/peer_handler.rs‎

Lines changed: 28 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ use routing::network_graph::NetGraphMsgHandler;
3232

3333
use prelude::*;
3434
use alloc::collections::LinkedList;
35-
use std::collections::{HashMap,hash_map,HashSet};
35+
use std::collections::{HashMap,hash_map};
3636
use std::sync::{Arc, Mutex};
3737
use core::sync::atomic::{AtomicUsize, Ordering};
3838
use core::{cmp, hash, fmt, mem};
@@ -286,9 +286,6 @@ impl Peer {
286286

287287
struct PeerHolder<Descriptor: SocketDescriptor> {
288288
peers: HashMap<Descriptor, Peer>,
289-
/// Added to by do_read_event for cases where we pushed a message onto the send buffer but
290-
/// didn't call do_attempt_write_data to avoid reentrancy. Cleared in process_events()
291-
peers_needing_send: HashSet<Descriptor>,
292289
/// Only add to this set when noise completes:
293290
node_id_to_descriptor: HashMap<PublicKey, Descriptor>,
294291
}
@@ -419,7 +416,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
419416
message_handler,
420417
peers: Mutex::new(PeerHolder {
421418
peers: HashMap::new(),
422-
peers_needing_send: HashSet::new(),
423419
node_id_to_descriptor: HashMap::new()
424420
}),
425421
our_node_secret,
@@ -651,14 +647,13 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
651647
}
652648

653649
/// Append a message to a peer's pending outbound/write buffer, and update the map of peers needing sends accordingly.
654-
fn enqueue_message<M: Encode + Writeable>(&self, peers_needing_send: &mut HashSet<Descriptor>, peer: &mut Peer, descriptor: Descriptor, message: &M) {
650+
fn enqueue_message<M: Encode + Writeable>(&self, peer: &mut Peer, message: &M) {
655651
let mut buffer = VecWriter(Vec::new());
656652
wire::write(message, &mut buffer).unwrap(); // crash if the write failed
657653
let encoded_message = buffer.0;
658654

659655
log_trace!(self.logger, "Enqueueing message of type {} to {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
660656
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_message[..]));
661-
peers_needing_send.insert(descriptor);
662657
}
663658

664659
fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: &[u8]) -> Result<bool, PeerHandleError> {
@@ -702,7 +697,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
702697
},
703698
msgs::ErrorAction::SendErrorMessage { msg } => {
704699
log_trace!(self.logger, "Got Err handling message, sending Error message because {}", e.err);
705-
self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &msg);
700+
self.enqueue_message(peer, &msg);
706701
continue;
707702
},
708703
}
@@ -744,7 +739,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
744739
insert_node_id!();
745740
let features = InitFeatures::known();
746741
let resp = msgs::Init { features };
747-
self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp);
742+
self.enqueue_message(peer, &resp);
748743
},
749744
NextNoiseStep::ActThree => {
750745
let their_node_id = try_potential_handleerror!(peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..]));
@@ -754,7 +749,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
754749
insert_node_id!();
755750
let features = InitFeatures::known();
756751
let resp = msgs::Init { features };
757-
self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp);
752+
self.enqueue_message(peer, &resp);
758753
},
759754
NextNoiseStep::NoiseComplete => {
760755
if peer.pending_read_is_header {
@@ -802,7 +797,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
802797
}
803798
};
804799

805-
match self.handle_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), message) {
800+
match self.handle_message(peer, message) {
806801
Err(handling_error) => match handling_error {
807802
MessageHandlingError::PeerHandleError(e) => { return Err(e) },
808803
MessageHandlingError::LightningError(e) => {
@@ -837,7 +832,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
837832

838833
/// Process an incoming message and return a decision (ok, lightning error, peer handling error) regarding the next action with the peer
839834
/// Returns the message back if it needs to be broadcasted to all other peers.
840-
fn handle_message(&self, peers_needing_send: &mut HashSet<Descriptor>, peer: &mut Peer, peer_descriptor: Descriptor, message: wire::Message) -> Result<Option<wire::Message>, MessageHandlingError> {
835+
fn handle_message(&self, peer: &mut Peer, message: wire::Message) -> Result<Option<wire::Message>, MessageHandlingError> {
841836
log_trace!(self.logger, "Received message of type {} from {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
842837

843838
// Need an Init as first message
@@ -872,7 +867,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
872867

873868
if msg.features.initial_routing_sync() {
874869
peer.sync_status = InitSyncTracker::ChannelsSyncing(0);
875-
peers_needing_send.insert(peer_descriptor.clone());
876870
}
877871
if !msg.features.supports_static_remote_key() {
878872
log_debug!(self.logger, "Peer {} does not support static remote key, disconnecting with no_connection_possible", log_pubkey!(peer.their_node_id.unwrap()));
@@ -907,7 +901,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
907901
wire::Message::Ping(msg) => {
908902
if msg.ponglen < 65532 {
909903
let resp = msgs::Pong { byteslen: msg.ponglen };
910-
self.enqueue_message(peers_needing_send, peer, peer_descriptor.clone(), &resp);
904+
self.enqueue_message(peer, &resp);
911905
}
912906
},
913907
wire::Message::Pong(_msg) => {
@@ -1029,7 +1023,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
10291023
wire::Message::ChannelAnnouncement(ref msg) => {
10301024
let encoded_msg = encode_msg!(msg);
10311025

1032-
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
1026+
for (_, ref mut peer) in peers.peers.iter_mut() {
10331027
if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
10341028
!peer.should_forward_channel_announcement(msg.contents.short_channel_id) {
10351029
continue
@@ -1045,13 +1039,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
10451039
continue;
10461040
}
10471041
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
1048-
peers.peers_needing_send.insert((*descriptor).clone());
10491042
}
10501043
},
10511044
wire::Message::NodeAnnouncement(ref msg) => {
10521045
let encoded_msg = encode_msg!(msg);
10531046

1054-
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
1047+
for (_, ref mut peer) in peers.peers.iter_mut() {
10551048
if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
10561049
!peer.should_forward_node_announcement(msg.contents.node_id) {
10571050
continue
@@ -1066,13 +1059,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
10661059
continue;
10671060
}
10681061
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
1069-
peers.peers_needing_send.insert((*descriptor).clone());
10701062
}
10711063
},
10721064
wire::Message::ChannelUpdate(ref msg) => {
10731065
let encoded_msg = encode_msg!(msg);
10741066

1075-
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
1067+
for (_, ref mut peer) in peers.peers.iter_mut() {
10761068
if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
10771069
!peer.should_forward_channel_announcement(msg.contents.short_channel_id) {
10781070
continue
@@ -1084,7 +1076,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
10841076
continue;
10851077
}
10861078
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
1087-
peers.peers_needing_send.insert((*descriptor).clone());
10881079
}
10891080
},
10901081
_ => debug_assert!(false, "We shouldn't attempt to forward anything but gossip messages"),
@@ -1131,17 +1122,15 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
11311122
log_trace!(self.logger, "Handling SendAcceptChannel event in peer_handler for node {} for channel {}",
11321123
log_pubkey!(node_id),
11331124
log_bytes!(msg.temporary_channel_id));
1134-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1125+
let (_, peer) = get_peer_for_forwarding!(node_id);
11351126
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1136-
self.do_attempt_write_data(&mut descriptor, peer);
11371127
},
11381128
MessageSendEvent::SendOpenChannel { ref node_id, ref msg } => {
11391129
log_trace!(self.logger, "Handling SendOpenChannel event in peer_handler for node {} for channel {}",
11401130
log_pubkey!(node_id),
11411131
log_bytes!(msg.temporary_channel_id));
1142-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1132+
let (_, peer) = get_peer_for_forwarding!(node_id);
11431133
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1144-
self.do_attempt_write_data(&mut descriptor, peer);
11451134
},
11461135
MessageSendEvent::SendFundingCreated { ref node_id, ref msg } => {
11471136
log_trace!(self.logger, "Handling SendFundingCreated event in peer_handler for node {} for channel {} (which becomes {})",
@@ -1150,35 +1139,31 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
11501139
log_funding_channel_id!(msg.funding_txid, msg.funding_output_index));
11511140
// TODO: If the peer is gone we should generate a DiscardFunding event
11521141
// indicating to the wallet that they should just throw away this funding transaction
1153-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1142+
let (_, peer) = get_peer_for_forwarding!(node_id);
11541143
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1155-
self.do_attempt_write_data(&mut descriptor, peer);
11561144
},
11571145
MessageSendEvent::SendFundingSigned { ref node_id, ref msg } => {
11581146
log_trace!(self.logger, "Handling SendFundingSigned event in peer_handler for node {} for channel {}",
11591147
log_pubkey!(node_id),
11601148
log_bytes!(msg.channel_id));
11611149
// TODO: If the peer is gone we should generate a DiscardFunding event
11621150
// indicating to the wallet that they should just throw away this funding transaction
1163-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1151+
let (_, peer) = get_peer_for_forwarding!(node_id);
11641152
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1165-
self.do_attempt_write_data(&mut descriptor, peer);
11661153
},
11671154
MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
11681155
log_trace!(self.logger, "Handling SendFundingLocked event in peer_handler for node {} for channel {}",
11691156
log_pubkey!(node_id),
11701157
log_bytes!(msg.channel_id));
1171-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1158+
let (_, peer) = get_peer_for_forwarding!(node_id);
11721159
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1173-
self.do_attempt_write_data(&mut descriptor, peer);
11741160
},
11751161
MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
11761162
log_trace!(self.logger, "Handling SendAnnouncementSignatures event in peer_handler for node {} for channel {})",
11771163
log_pubkey!(node_id),
11781164
log_bytes!(msg.channel_id));
1179-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1165+
let (_, peer) = get_peer_for_forwarding!(node_id);
11801166
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1181-
self.do_attempt_write_data(&mut descriptor, peer);
11821167
},
11831168
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 } } => {
11841169
log_trace!(self.logger, "Handling UpdateHTLCs event in peer_handler for node {} with {} adds, {} fulfills, {} fails for channel {}",
@@ -1187,7 +1172,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
11871172
update_fulfill_htlcs.len(),
11881173
update_fail_htlcs.len(),
11891174
log_bytes!(commitment_signed.channel_id));
1190-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1175+
let (_, peer) = get_peer_for_forwarding!(node_id);
11911176
for msg in update_add_htlcs {
11921177
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
11931178
}
@@ -1204,39 +1189,34 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
12041189
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
12051190
}
12061191
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(commitment_signed)));
1207-
self.do_attempt_write_data(&mut descriptor, peer);
12081192
},
12091193
MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
12101194
log_trace!(self.logger, "Handling SendRevokeAndACK event in peer_handler for node {} for channel {}",
12111195
log_pubkey!(node_id),
12121196
log_bytes!(msg.channel_id));
1213-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1197+
let (_, peer) = get_peer_for_forwarding!(node_id);
12141198
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1215-
self.do_attempt_write_data(&mut descriptor, peer);
12161199
},
12171200
MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
12181201
log_trace!(self.logger, "Handling SendClosingSigned event in peer_handler for node {} for channel {}",
12191202
log_pubkey!(node_id),
12201203
log_bytes!(msg.channel_id));
1221-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1204+
let (_, peer) = get_peer_for_forwarding!(node_id);
12221205
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1223-
self.do_attempt_write_data(&mut descriptor, peer);
12241206
},
12251207
MessageSendEvent::SendShutdown { ref node_id, ref msg } => {
12261208
log_trace!(self.logger, "Handling Shutdown event in peer_handler for node {} for channel {}",
12271209
log_pubkey!(node_id),
12281210
log_bytes!(msg.channel_id));
1229-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1211+
let (_, peer) = get_peer_for_forwarding!(node_id);
12301212
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1231-
self.do_attempt_write_data(&mut descriptor, peer);
12321213
},
12331214
MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } => {
12341215
log_trace!(self.logger, "Handling SendChannelReestablish event in peer_handler for node {} for channel {}",
12351216
log_pubkey!(node_id),
12361217
log_bytes!(msg.channel_id));
1237-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1218+
let (_, peer) = get_peer_for_forwarding!(node_id);
12381219
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1239-
self.do_attempt_write_data(&mut descriptor, peer);
12401220
},
12411221
MessageSendEvent::BroadcastChannelAnnouncement { msg, update_msg } => {
12421222
log_trace!(self.logger, "Handling BroadcastChannelAnnouncement event in peer_handler for short channel id {}", msg.contents.short_channel_id);
@@ -1264,7 +1244,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
12641244
match *action {
12651245
msgs::ErrorAction::DisconnectPeer { ref msg } => {
12661246
if let Some(mut descriptor) = peers.node_id_to_descriptor.remove(node_id) {
1267-
peers.peers_needing_send.remove(&descriptor);
12681247
if let Some(mut peer) = peers.peers.remove(&descriptor) {
12691248
if let Some(ref msg) = *msg {
12701249
log_trace!(self.logger, "Handling DisconnectPeer HandleError event in peer_handler for node {} with message {}",
@@ -1287,21 +1266,18 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
12871266
log_trace!(self.logger, "Handling SendErrorMessage HandleError event in peer_handler for node {} with message {}",
12881267
log_pubkey!(node_id),
12891268
msg.data);
1290-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1269+
let (_, peer) = get_peer_for_forwarding!(node_id);
12911270
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1292-
self.do_attempt_write_data(&mut descriptor, peer);
12931271
},
12941272
}
12951273
},
12961274
MessageSendEvent::SendChannelRangeQuery { ref node_id, ref msg } => {
1297-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1275+
let (_, peer) = get_peer_for_forwarding!(node_id);
12981276
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1299-
self.do_attempt_write_data(&mut descriptor, peer);
13001277
},
13011278
MessageSendEvent::SendShortIdsQuery { ref node_id, ref msg } => {
1302-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1279+
let (_, peer) = get_peer_for_forwarding!(node_id);
13031280
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1304-
self.do_attempt_write_data(&mut descriptor, peer);
13051281
}
13061282
MessageSendEvent::SendReplyChannelRange { ref node_id, ref msg } => {
13071283
log_trace!(self.logger, "Handling SendReplyChannelRange event in peer_handler for node {} with num_scids={} first_blocknum={} number_of_blocks={}, sync_complete={}",
@@ -1310,18 +1286,14 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
13101286
msg.first_blocknum,
13111287
msg.number_of_blocks,
13121288
msg.sync_complete);
1313-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1289+
let (_, peer) = get_peer_for_forwarding!(node_id);
13141290
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1315-
self.do_attempt_write_data(&mut descriptor, peer);
13161291
}
13171292
}
13181293
}
13191294

1320-
for mut descriptor in peers.peers_needing_send.drain() {
1321-
match peers.peers.get_mut(&descriptor) {
1322-
Some(peer) => self.do_attempt_write_data(&mut descriptor, peer),
1323-
None => panic!("Inconsistent peers set state!"),
1324-
}
1295+
for (descriptor, ref mut peer) in peers.peers.iter_mut() {
1296+
self.do_attempt_write_data(&mut (*descriptor).clone(), peer);
13251297
}
13261298
}
13271299
}
@@ -1340,7 +1312,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
13401312

13411313
fn disconnect_event_internal(&self, descriptor: &Descriptor, no_connection_possible: bool) {
13421314
let mut peers = self.peers.lock().unwrap();
1343-
peers.peers_needing_send.remove(descriptor);
13441315
let peer_option = peers.peers.remove(descriptor);
13451316
match peer_option {
13461317
None => panic!("Descriptor for disconnect_event is not already known to PeerManager"),
@@ -1368,7 +1339,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
13681339
if let Some(mut descriptor) = peers_lock.node_id_to_descriptor.remove(&node_id) {
13691340
log_trace!(self.logger, "Disconnecting peer with id {} due to client request", node_id);
13701341
peers_lock.peers.remove(&descriptor);
1371-
peers_lock.peers_needing_send.remove(&descriptor);
13721342
self.message_handler.chan_handler.peer_disconnected(&node_id, no_connection_possible);
13731343
descriptor.disconnect_socket();
13741344
}
@@ -1382,14 +1352,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
13821352
let mut peers_lock = self.peers.lock().unwrap();
13831353
{
13841354
let peers = &mut *peers_lock;
1385-
let peers_needing_send = &mut peers.peers_needing_send;
13861355
let node_id_to_descriptor = &mut peers.node_id_to_descriptor;
13871356
let peers = &mut peers.peers;
13881357
let mut descriptors_needing_disconnect = Vec::new();
13891358

13901359
peers.retain(|descriptor, peer| {
13911360
if peer.awaiting_pong {
1392-
peers_needing_send.remove(descriptor);
13931361
descriptors_needing_disconnect.push(descriptor.clone());
13941362
match peer.their_node_id {
13951363
Some(node_id) => {

0 commit comments

Comments
 (0)