Merge pull request #490 from jkczyz/2020-02-initial-routing-sync

Refactor logic for setting initial_routing_sync feature bit

diff --combined lightning/src/ln/peer_handler.rs
index 327664c7fc2420128b0d9d8be3d99b9cf8d8ee7b,2e7ce4e2973ce57d54c2285a1fd6e2792542711b..6576da806afb48c938791f47c0fee55880b5452a
--- 1/lightning/src/ln/peer_handler.rs
--- 2/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@@ -189,7 -189,6 +189,6 @@@ pub struct PeerManager<Descriptor: Sock
        peer_counter_low: AtomicUsize,
        peer_counter_high: AtomicUsize,
  
-       initial_syncs_sent: AtomicUsize,
        logger: Arc<Logger>,
  }
  
@@@ -212,9 -211,6 +211,6 @@@ macro_rules! encode_msg 
        }}
  }
  
- //TODO: Really should do something smarter for this
- const INITIAL_SYNCS_TO_SEND: usize = 5;
- 
  /// Manages and reacts to connection events. You probably want to use file descriptors as PeerIds.
  /// PeerIds may repeat, but only after disconnect_event() has been called.
  impl<Descriptor: SocketDescriptor, CM: Deref> PeerManager<Descriptor, CM> where CM::Target: msgs::ChannelMessageHandler {
@@@ -236,7 -232,6 +232,6 @@@
                        ephemeral_key_midstate,
                        peer_counter_low: AtomicUsize::new(0),
                        peer_counter_high: AtomicUsize::new(0),
-                       initial_syncs_sent: AtomicUsize::new(0),
                        logger,
                }
        }
@@@ -517,6 -512,37 +512,6 @@@
                                                                }
                                                        }
  
 -                                                      macro_rules! try_potential_decodeerror {
 -                                                              ($thing: expr) => {
 -                                                                      match $thing {
 -                                                                              Ok(x) => x,
 -                                                                              Err(e) => {
 -                                                                                      match e {
 -                                                                                              msgs::DecodeError::UnknownVersion => return Err(PeerHandleError{ no_connection_possible: false }),
 -                                                                                              msgs::DecodeError::UnknownRequiredFeature => {
 -                                                                                                      log_debug!(self, "Got a channel/node announcement with an known required feature flag, you may want to update!");
 -                                                                                                      continue;
 -                                                                                              },
 -                                                                                              msgs::DecodeError::InvalidValue => {
 -                                                                                                      log_debug!(self, "Got an invalid value while deserializing message");
 -                                                                                                      return Err(PeerHandleError{ no_connection_possible: false });
 -                                                                                              },
 -                                                                                              msgs::DecodeError::ShortRead => {
 -                                                                                                      log_debug!(self, "Deserialization failed due to shortness of message");
 -                                                                                                      return Err(PeerHandleError{ no_connection_possible: false });
 -                                                                                              },
 -                                                                                              msgs::DecodeError::ExtraAddressesPerType => {
 -                                                                                                      log_debug!(self, "Error decoding message, ignoring due to lnd spec incompatibility. See https://github.com/lightningnetwork/lnd/issues/1407");
 -                                                                                                      continue;
 -                                                                                              },
 -                                                                                              msgs::DecodeError::BadLengthDescriptor => return Err(PeerHandleError{ no_connection_possible: false }),
 -                                                                                              msgs::DecodeError::Io(_) => return Err(PeerHandleError{ no_connection_possible: false }),
 -                                                                                      }
 -                                                                              }
 -                                                                      };
 -                                                              }
 -                                                      }
 -
                                                        macro_rules! insert_node_id {
                                                                () => {
                                                                        match peers.node_id_to_descriptor.entry(peer.their_node_id.unwrap()) {
@@@ -549,8 -575,7 +544,7 @@@
                                                                        peer.their_node_id = Some(their_node_id);
                                                                        insert_node_id!();
                                                                        let mut features = InitFeatures::supported();
-                                                                       if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
-                                                                               self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
+                                                                       if self.message_handler.route_handler.should_request_full_sync(&peer.their_node_id.unwrap()) {
                                                                                features.set_initial_routing_sync();
                                                                        }
  
@@@ -582,34 -607,7 +576,34 @@@
                                                                                peer.pending_read_is_header = true;
  
                                                                                let mut reader = ::std::io::Cursor::new(&msg_data[..]);
 -                                                                              let message = try_potential_decodeerror!(wire::read(&mut reader));
 +                                                                              let message_result = wire::read(&mut reader);
 +                                                                              let message = match message_result {
 +                                                                                      Ok(x) => x,
 +                                                                                      Err(e) => {
 +                                                                                              match e {
 +                                                                                                      msgs::DecodeError::UnknownVersion => return Err(PeerHandleError { no_connection_possible: false }),
 +                                                                                                      msgs::DecodeError::UnknownRequiredFeature => {
 +                                                                                                              log_debug!(self, "Got a channel/node announcement with an known required feature flag, you may want to update!");
 +                                                                                                              continue;
 +                                                                                                      }
 +                                                                                                      msgs::DecodeError::InvalidValue => {
 +                                                                                                              log_debug!(self, "Got an invalid value while deserializing message");
 +                                                                                                              return Err(PeerHandleError { no_connection_possible: false });
 +                                                                                                      }
 +                                                                                                      msgs::DecodeError::ShortRead => {
 +                                                                                                              log_debug!(self, "Deserialization failed due to shortness of message");
 +                                                                                                              return Err(PeerHandleError { no_connection_possible: false });
 +                                                                                                      }
 +                                                                                                      msgs::DecodeError::ExtraAddressesPerType => {
 +                                                                                                              log_debug!(self, "Error decoding message, ignoring due to lnd spec incompatibility. See https://github.com/lightningnetwork/lnd/issues/1407");
 +                                                                                                              continue;
 +                                                                                                      }
 +                                                                                                      msgs::DecodeError::BadLengthDescriptor => return Err(PeerHandleError { no_connection_possible: false }),
 +                                                                                                      msgs::DecodeError::Io(_) => return Err(PeerHandleError { no_connection_possible: false }),
 +                                                                                              }
 +                                                                                      }
 +                                                                              };
 +
                                                                                log_trace!(self, "Received message of type {} from {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
  
                                                                                // Need an Init as first message
@@@ -648,8 -646,7 +642,7 @@@
  
                                                                                                if !peer.outbound {
                                                                                                        let mut features = InitFeatures::supported();
-                                                                                                       if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
-                                                                                                               self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
+                                                                                                       if self.message_handler.route_handler.should_request_full_sync(&peer.their_node_id.unwrap()) {
                                                                                                                features.set_initial_routing_sync();
                                                                                                        }