fix: redirect to our elders on mismatching GetSectionRequest as adult

src/routing/approved.rs

@@ -201,7 +201,7 @@ impl Approved {
         &mut self,
         sender: SocketAddr,
         message: Query,
-    ) -> Result<Vec<Command>> {
+    ) -> Vec<Command> {
         match message {
             Query::GetSectionRequest(name) => {
                 debug!("Received GetSectionRequest({}) from {}", name, sender);
@@ -217,20 +217,24 @@ impl Approved {
                             .map(|peer| (*peer.name(), *peer.addr()))
                             .collect(),
                     }
-                } else if let Some(section) = self.network.closest(&name) {
+                } else {
+                    // If we are elder, we should know a section that is closer to `name` that us.
+                    // Otherwise redirect to our elders.
+                    let section = self
+                        .network
+                        .closest(&name)
+                        .unwrap_or_else(|| self.section.elders_info());
                     let addrs = section.peers().map(Peer::addr).copied().collect();
                     GetSectionResponse::Redirect(addrs)
-                } else {
-                    return Err(Error::InvalidDstLocation);
                 };
                 let response = Query::GetSectionResponse(response);
                 debug!("Sending {:?} to {}", response, sender);
 
-                Ok(vec![Command::SendMessage {
+                vec![Command::SendMessage {
                     recipients: vec![sender],
                     delivery_group_size: 1,
                     message: MessageType::InfrastructureQuery(response),
-                }])
+                }]
             }
             Query::GetSectionResponse(_) => {
                 if let Some(RelocateState::InProgress(tx)) = &mut self.relocate_state {
@@ -240,7 +244,7 @@ impl Approved {
                         .await;
                 }
 
-                Ok(vec![])
+                vec![]
             }
         }
     }

src/routing/stage.rs

@@ -101,13 +101,12 @@ impl Stage {
                     .handle_message(sender, message)
                     .await
             }
-            Command::HandleInfrastructureQuery { sender, message } => {
-                self.state
-                    .lock()
-                    .await
-                    .handle_infrastructure_query(sender, message)
-                    .await
-            }
+            Command::HandleInfrastructureQuery { sender, message } => Ok(self
+                .state
+                .lock()
+                .await
+                .handle_infrastructure_query(sender, message)
+                .await),
             Command::HandleTimeout(token) => self.state.lock().await.handle_timeout(token),
             Command::HandleVote { vote, proof_share } => {
                 self.state.lock().await.handle_vote(vote, proof_share)

src/routing/tests/mod.rs

@@ -47,7 +47,7 @@ use tokio::sync::mpsc;
 use xor_name::{Prefix, XorName};
 
 #[tokio::test]
-async fn receive_get_section_request() -> Result<()> {
+async fn receive_matching_get_section_request_as_elder() -> Result<()> {
     let node = create_node();
     let state = Approved::first_node(node, mpsc::unbounded_channel().0)?;
     let stage = Stage::new(state, create_comm()?);
@@ -82,6 +82,56 @@ async fn receive_get_section_request() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn receive_mismatching_get_section_request_as_adult() -> Result<()> {
+    let good_prefix = Prefix::default().pushed(false);
+    let bad_prefix = Prefix::default().pushed(true);
+
+    let sk_set = SecretKeySet::random();
+    let (elders_info, _) = gen_elders_info(good_prefix, ELDER_SIZE);
+    let elders_addrs: Vec<_> = elders_info.peers().map(Peer::addr).copied().collect();
+    let (section, _) = create_section(&sk_set, &elders_info)?;
+
+    let node = create_node();
+    let state = Approved::new(node, section, None, mpsc::unbounded_channel().0);
+    let stage = Stage::new(state, create_comm()?);
+
+    let new_node_name = bad_prefix.substituted_in(rand::random());
+    let new_node_addr = gen_addr();
+
+    let message = Query::GetSectionRequest(new_node_name);
+
+    let mut commands = stage
+        .handle_command(Command::HandleInfrastructureQuery {
+            sender: new_node_addr,
+            message,
+        })
+        .await?
+        .into_iter();
+
+    let (recipients, message) = assert_matches!(
+        commands.next(),
+        Some(Command::SendMessage {
+            recipients,
+            message: MessageType::InfrastructureQuery(message), ..
+        }) => (recipients, message)
+    );
+
+    assert_eq!(recipients, [new_node_addr]);
+    assert_matches!(
+        message,
+        Query::GetSectionResponse(GetSectionResponse::Redirect(addrs)) => {
+            assert_eq!(addrs, elders_addrs)
+        }
+    );
+
+    Ok(())
+}
+
+// TODO: add test `receive_mismatching_get_section_request_as_elder` - should respond with
+// `Redirect` response containing addresses of nodes in a section that is closer to the joining
+// name.
+
 #[tokio::test]
 async fn receive_join_request_without_resource_proof_response() -> Result<()> {
     let node = create_node();