Skip to content

Commit 72a668b

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 cd88f1a commit 72a668b

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};
@@ -288,9 +288,6 @@ impl Peer {
288288

289289
struct PeerHolder<Descriptor: SocketDescriptor> {
290290
peers: HashMap<Descriptor, Peer>,
291-
/// Added to by do_read_event for cases where we pushed a message onto the send buffer but
292-
/// didn't call do_attempt_write_data to avoid reentrancy. Cleared in process_events()
293-
peers_needing_send: HashSet<Descriptor>,
294291
/// Only add to this set when noise completes:
295292
node_id_to_descriptor: HashMap<PublicKey, Descriptor>,
296293
}
@@ -421,7 +418,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
421418
message_handler,
422419
peers: Mutex::new(PeerHolder {
423420
peers: HashMap::new(),
424-
peers_needing_send: HashSet::new(),
425421
node_id_to_descriptor: HashMap::new()
426422
}),
427423
our_node_secret,
@@ -653,14 +649,13 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
653649
}
654650

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

661657
log_trace!(self.logger, "Enqueueing message of type {} to {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
662658
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_message[..]));
663-
peers_needing_send.insert(descriptor);
664659
}
665660

666661
fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: &[u8]) -> Result<bool, PeerHandleError> {
@@ -704,7 +699,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
704699
},
705700
msgs::ErrorAction::SendErrorMessage { msg } => {
706701
log_trace!(self.logger, "Got Err handling message, sending Error message because {}", e.err);
707-
self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &msg);
702+
self.enqueue_message(peer, &msg);
708703
continue;
709704
},
710705
}
@@ -746,7 +741,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
746741
insert_node_id!();
747742
let features = InitFeatures::known();
748743
let resp = msgs::Init { features };
749-
self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp);
744+
self.enqueue_message(peer, &resp);
750745
},
751746
NextNoiseStep::ActThree => {
752747
let their_node_id = try_potential_handleerror!(peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..]));
@@ -756,7 +751,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
756751
insert_node_id!();
757752
let features = InitFeatures::known();
758753
let resp = msgs::Init { features };
759-
self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp);
754+
self.enqueue_message(peer, &resp);
760755
},
761756
NextNoiseStep::NoiseComplete => {
762757
if peer.pending_read_is_header {
@@ -804,7 +799,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
804799
}
805800
};
806801

807-
match self.handle_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), message) {
802+
match self.handle_message(peer, message) {
808803
Err(handling_error) => match handling_error {
809804
MessageHandlingError::PeerHandleError(e) => { return Err(e) },
810805
MessageHandlingError::LightningError(e) => {
@@ -839,7 +834,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
839834

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

845840
// Need an Init as first message
@@ -874,7 +869,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
874869

875870
if msg.features.initial_routing_sync() {
876871
peer.sync_status = InitSyncTracker::ChannelsSyncing(0);
877-
peers_needing_send.insert(peer_descriptor.clone());
878872
}
879873
if !msg.features.supports_static_remote_key() {
880874
log_debug!(self.logger, "Peer {} does not support static remote key, disconnecting with no_connection_possible", log_pubkey!(peer.their_node_id.unwrap()));
@@ -909,7 +903,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
909903
wire::Message::Ping(msg) => {
910904
if msg.ponglen < 65532 {
911905
let resp = msgs::Pong { byteslen: msg.ponglen };
912-
self.enqueue_message(peers_needing_send, peer, peer_descriptor.clone(), &resp);
906+
self.enqueue_message(peer, &resp);
913907
}
914908
},
915909
wire::Message::Pong(_msg) => {
@@ -1031,7 +1025,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
10311025
wire::Message::ChannelAnnouncement(ref msg) => {
10321026
let encoded_msg = encode_msg!(msg);
10331027

1034-
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
1028+
for (_, ref mut peer) in peers.peers.iter_mut() {
10351029
if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
10361030
!peer.should_forward_channel_announcement(msg.contents.short_channel_id) {
10371031
continue
@@ -1047,13 +1041,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
10471041
continue;
10481042
}
10491043
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
1050-
peers.peers_needing_send.insert((*descriptor).clone());
10511044
}
10521045
},
10531046
wire::Message::NodeAnnouncement(ref msg) => {
10541047
let encoded_msg = encode_msg!(msg);
10551048

1056-
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
1049+
for (_, ref mut peer) in peers.peers.iter_mut() {
10571050
if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
10581051
!peer.should_forward_node_announcement(msg.contents.node_id) {
10591052
continue
@@ -1068,13 +1061,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
10681061
continue;
10691062
}
10701063
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
1071-
peers.peers_needing_send.insert((*descriptor).clone());
10721064
}
10731065
},
10741066
wire::Message::ChannelUpdate(ref msg) => {
10751067
let encoded_msg = encode_msg!(msg);
10761068

1077-
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
1069+
for (_, ref mut peer) in peers.peers.iter_mut() {
10781070
if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
10791071
!peer.should_forward_channel_announcement(msg.contents.short_channel_id) {
10801072
continue
@@ -1086,7 +1078,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
10861078
continue;
10871079
}
10881080
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
1089-
peers.peers_needing_send.insert((*descriptor).clone());
10901081
}
10911082
},
10921083
_ => debug_assert!(false, "We shouldn't attempt to forward anything but gossip messages"),
@@ -1133,17 +1124,15 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
11331124
log_trace!(self.logger, "Handling SendAcceptChannel event in peer_handler for node {} for channel {}",
11341125
log_pubkey!(node_id),
11351126
log_bytes!(msg.temporary_channel_id));
1136-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1127+
let (_, peer) = get_peer_for_forwarding!(node_id);
11371128
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1138-
self.do_attempt_write_data(&mut descriptor, peer);
11391129
},
11401130
MessageSendEvent::SendOpenChannel { ref node_id, ref msg } => {
11411131
log_trace!(self.logger, "Handling SendOpenChannel event in peer_handler for node {} for channel {}",
11421132
log_pubkey!(node_id),
11431133
log_bytes!(msg.temporary_channel_id));
1144-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1134+
let (_, peer) = get_peer_for_forwarding!(node_id);
11451135
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1146-
self.do_attempt_write_data(&mut descriptor, peer);
11471136
},
11481137
MessageSendEvent::SendFundingCreated { ref node_id, ref msg } => {
11491138
log_trace!(self.logger, "Handling SendFundingCreated event in peer_handler for node {} for channel {} (which becomes {})",
@@ -1152,33 +1141,29 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref> PeerManager<D
11521141
log_funding_channel_id!(msg.funding_txid, msg.funding_output_index));
11531142
// TODO: If the peer is gone we should generate a DiscardFunding event
11541143
// indicating to the wallet that they should just throw away this funding transaction
1155-
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id);
1144+
let (_, peer) = get_peer_for_forwarding!(node_id);
11561145
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg)));
1157-
self.do_attempt_write_data(&mut descriptor, peer);
11581146
},
11591147
MessageSendEvent::SendFundingSigned { ref node_id, ref msg } => {
11601148
log_trace!(self.logger, "Handling SendFundingSigned event in peer_handler for node {} for channel {}",
11611149
log_pubkey!(node_id),
11621150
log_bytes!(msg.channel_id));
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)