Simplify routing table design

Instead of doing dynamic table resizing, just allocate all the memory
upfront.

Author: Internal-Compiler-Error

src/dht_service.rs

@@ -137,7 +137,6 @@ impl DhtV4 {
         while let Some(_) = bootstrap_join_set.join_next().await {}
         drop(bootstrap_join_set);
 
-        println!("I should be done");
         info!("DHT bootstrapped, routing table has {} nodes", peer_guide.node_count());
 
         Ok(dht)
@@ -159,11 +158,13 @@ impl DhtV4 {
         let our_id = dht.our_id.clone();
 
         info!("bootstrapping with {peer}");
-        let response = timeout(Duration::from_secs(5), async {
+        let _response = timeout(Duration::from_secs(5), async {
             let node_id = dht.ping(peer).await?;
             dht.routing_table.add(node_id, peer);
 
-            dht.find_node(our_id).await;
+            // the find node only obviously we know ourselves, this only serves us to get us info
+            // about other nodes
+            let _ = dht.find_node(our_id).await;
             println!("done finding node");
 
             Ok::<(), eyre::Report>(())

src/dht_service/dht_client.rs

@@ -74,7 +74,7 @@ impl DhtHandle {
     pub async fn find_node(self: Arc<Self>, target: NodeId) -> Result<NodeInfo, OurError> {
         // if we already know the node, then no need for any network requests
         if let Some(node) = (&self).routing_table.find(target) {
-            return Ok(node.contact);
+            return Ok(node);
         }
 
         let mut queried: HashSet<NodeInfo> = HashSet::new();
@@ -180,7 +180,7 @@ impl DhtHandle {
         //
         // if we already know the node, then no need for any network requests
         if let Some(node) = (&self).routing_table.find(resonsible) {
-            let (token, _nodes, peers) = self.send_get_peers_rpc(node.contact.contact().0, info_hash).await?;
+            let (token, _nodes, peers) = self.send_get_peers_rpc(node.contact().0, info_hash).await?;
             return Ok((
                 token.expect("A node directly responsible for a piece would return a token"),
                 peers,

src/dht_service/dht_server.rs

@@ -1,12 +1,8 @@
 use crate::{
     domain_knowledge::{InfoHash, NodeId, PeerContact, Token},
     message::{
-        announce_peer_query::AnnouncePeerQuery,
-        find_node_get_peers_response::{self, FindNodeGetPeersResponse},
-        find_node_query::{self, FindNodeQuery},
-        get_peers_query::GetPeersQuery,
-        ping_query::PingQuery,
-        Krpc,
+        announce_peer_query::AnnouncePeerQuery, find_node_query::FindNodeQuery, get_peers_query::GetPeersQuery,
+        ping_query::PingQuery, Krpc,
     },
 };
 use rand::RngCore;
@@ -24,7 +20,7 @@ use tokio::{
     task::Builder as TskBuilder,
     time::Instant,
 };
-use tracing::{error, info, info_span, trace, Instrument};
+use tracing::{info, info_span, trace, Instrument};
 
 use super::{peer_guide::PeerGuide, MessageBroker};
 #[derive(Debug)]

src/dht_service/peer_guide.rs

@@ -8,7 +8,7 @@ use tokio::sync::mpsc;
 use crate::{
     domain_knowledge::{NodeId, NodeInfo},
     message::Krpc,
-    routing::{Node, RoutingTable},
+    routing::RoutingTable,
 };
 
 #[derive(Debug)]
@@ -57,7 +57,7 @@ impl PeerGuide {
         routing_table.find_closest(target)
     }
 
-    pub fn find(&self, target: NodeId) -> Option<Node> {
+    pub fn find(&self, target: NodeId) -> Option<NodeInfo> {
         let routing_table = self.routing_table.lock().unwrap();
         routing_table.find(target)
     }

src/domain_knowledge.rs

@@ -3,7 +3,10 @@ use num::{traits::ops::bytes, BigUint};
 use smallvec::SmallVec;
 use std::{fmt::Debug, net::SocketAddrV4};
 
-#[derive(PartialEq, Eq, Hash, Clone, Copy)]
+const NODE_ID_LEN: usize = 20;
+pub const ZERO_DIST: [u8; NODE_ID_LEN] = [0; NODE_ID_LEN];
+
+#[derive(PartialEq, Eq, Hash, Clone, Copy, PartialOrd, Ord)]
 pub struct NodeId(pub [u8; 20]);
 
 impl Debug for NodeId {
@@ -36,6 +39,14 @@ impl NodeId {
         let node_id = BigUint::from_bytes_be(rhs.as_bytes());
         our_id ^ node_id
     }
+
+    pub fn dist(&self, rhs: &Self) -> [u8; 20] {
+        let mut dist = [0u8; 20];
+        for i in 0..20 {
+            dist[i] = self.0[i] ^ rhs.0[i]
+        }
+        dist
+    }
 }
 
 impl ToBencode for NodeId {
@@ -46,6 +57,25 @@ impl ToBencode for NodeId {
     }
 }
 
+// impl PartialOrd for NodeId {
+//     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+//         for (lhs, rhs) in self.0.iter().zip(other.0.iter()) {
+//             match lhs.cmp(rhs) {
+//                 Ordering::Equal => continue,
+//                 Ordering::Less => return Some(Ordering::Less),
+//                 Ordering::Greater => return Some(Ordering::Greater),
+//             }
+//         }
+//         Some(Ordering::Equal)
+//     }
+// }
+//
+// impl Ord for NodeId {
+//     fn cmp(&self, other: &Self) -> Ordering {
+//         self.partial_cmp(other).unwrap()
+//     }
+// }
+
 #[derive(PartialEq, Eq, Hash, Clone, Copy)]
 pub struct InfoHash(pub [u8; 20]);