Replaced DHT with custom one! Lets see if it works

crates/dht/src/bprotocol.rs

@@ -6,13 +6,12 @@ use std::{
 
 use bencode::ByteBuf;
 use clone_to_owned::CloneToOwned;
+use librqbit_core::id20::Id20;
 use serde::{
     de::{IgnoredAny, Unexpected},
     Deserialize, Deserializer, Serialize,
 };
 
-use crate::id20::Id20;
-
 #[derive(Debug)]
 enum MessageType {
     Request,

crates/dht/src/dht.rs

@@ -7,13 +7,12 @@ use crate::{
     bprotocol::{
         self, CompactNodeInfo, FindNodeRequest, GetPeersRequest, Message, MessageKind, Node,
     },
-    id20::Id20,
     routing_table::{InsertResult, RoutingTable},
 };
 use anyhow::Context;
 use bencode::ByteString;
 use futures::{stream::FuturesUnordered, StreamExt};
-use librqbit_core::peer_id::generate_peer_id;
+use librqbit_core::{id20::Id20, peer_id::generate_peer_id};
 use log::{debug, info, trace, warn};
 use parking_lot::Mutex;
 use tokio::{

crates/dht/src/id20.rs

@@ -1,131 +1 @@
-use std::{cmp::Ordering, str::FromStr};
 
-use serde::{Deserialize, Deserializer, Serialize};
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
-pub struct Id20(pub [u8; 20]);
-
-impl FromStr for Id20 {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut out = [0u8; 20];
-        if s.len() != 40 {
-            anyhow::bail!("expected a hex string of length 40")
-        };
-        hex::decode_to_slice(s, &mut out)?;
-        Ok(Id20(out))
-    }
-}
-
-impl std::fmt::Debug for Id20 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "<")?;
-        for byte in self.0 {
-            write!(f, "{:02x?}", byte)?;
-        }
-        write!(f, ">")?;
-        Ok(())
-    }
-}
-
-impl Serialize for Id20 {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_bytes(&self.0)
-    }
-}
-
-impl<'de> Deserialize<'de> for Id20 {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct Visitor;
-        impl<'de> serde::de::Visitor<'de> for Visitor {
-            type Value = Id20;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-                write!(formatter, "a 20 byte slice")
-            }
-            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                if v.len() != 20 {
-                    return Err(E::invalid_length(20, &self));
-                }
-                let mut buf = [0u8; 20];
-                buf.copy_from_slice(&v);
-                Ok(Id20(buf))
-            }
-        }
-        deserializer.deserialize_bytes(Visitor {})
-    }
-}
-
-impl Id20 {
-    pub fn distance(&self, other: &Id20) -> Id20 {
-        let mut xor = [0u8; 20];
-        for (idx, (s, o)) in self
-            .0
-            .iter()
-            .copied()
-            .zip(other.0.iter().copied())
-            .enumerate()
-        {
-            xor[idx] = s ^ o;
-        }
-        Id20(xor)
-    }
-    pub fn set_bit(&mut self, bit: u8, value: bool) {
-        let n = &mut self.0[(bit / 8) as usize];
-        if value {
-            *n |= 1 << (7 - bit % 8)
-        } else {
-            let mask = !(1 << (7 - bit % 8));
-            *n &= mask;
-        }
-    }
-    pub fn set_bits_range(&mut self, r: std::ops::Range<u8>, value: bool) {
-        for bit in r {
-            self.set_bit(bit, value)
-        }
-    }
-}
-
-impl Ord for Id20 {
-    fn cmp(&self, other: &Id20) -> Ordering {
-        for (s, o) in self.0.iter().copied().zip(other.0.iter().copied()) {
-            match s.cmp(&o) {
-                Ordering::Less => return Ordering::Less,
-                Ordering::Equal => continue,
-                Ordering::Greater => return Ordering::Greater,
-            }
-        }
-        Ordering::Equal
-    }
-}
-
-impl PartialOrd<Id20> for Id20 {
-    fn partial_cmp(&self, other: &Id20) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Id20;
-
-    #[test]
-    fn test_set_bit_range() {
-        let mut id = Id20([0u8; 20]);
-        id.set_bits_range(9..17, true);
-        assert_eq!(
-            id,
-            Id20([0, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-        )
-    }
-}

crates/dht/src/lib.rs

@@ -1,4 +1,6 @@
-pub mod bprotocol;
-pub mod dht;
-pub mod id20;
-pub mod routing_table;
+mod bprotocol;
+mod dht;
+mod routing_table;
+
+pub use dht::Dht;
+pub use librqbit_core::id20::Id20;

crates/dht/src/main.rs

@@ -1,7 +1,7 @@
-use std::{collections::HashSet, str::FromStr, time::Duration};
+use std::{collections::HashSet, str::FromStr};
 
 use anyhow::Context;
-use dht::{dht::Dht, id20::Id20};
+use dht::{Dht, Id20};
 use tokio_stream::StreamExt;
 
 #[tokio::main]

crates/dht/src/routing_table.rs

@@ -3,10 +3,9 @@ use std::{
     time::{Duration, Instant},
 };
 
+use librqbit_core::id20::Id20;
 use log::debug;
 
-use crate::id20::Id20;
-
 #[derive(Debug)]
 enum BucketTreeNode {
     Leaf(Vec<RoutingTableNode>),
@@ -426,9 +425,10 @@ impl RoutingTable {
 mod tests {
     use std::net::SocketAddrV4;
 
+    use librqbit_core::id20::Id20;
     use rand::Rng;
 
-    use crate::{id20::Id20, routing_table::compute_split_start_end};
+    use crate::routing_table::compute_split_start_end;
 
     use super::RoutingTable;