Merge pull request #11 from seun-ja/8-kademlia-data-propagation

8 kademlia data propagation

Author: seun-ja

Cargo.lock

@@ -15,8 +15,8 @@ libp2p = { version = "0.55.0", features = [
     "quic",
     "request-response",
     "cbor",
-    "gossipsub",
     "kad",
+    "mdns",
 ] }
 
 # Serde

Cargo.toml

@@ -76,7 +76,7 @@ pub struct TransactionData {
 
 #[typetag::serde(tag = "type")]
 pub trait Transactable: Debug + Send + Sync + DynClone + Display {
-    // TODO: Implement the _submit method to submit the transaction to the network.
+    // TODO: #9 Implement the _submit method to submit the transaction to the network.
     fn _submit(&self) -> Result<(), TransactionError>;
     fn sign(&self, keypair: &Keypair) -> Result<(), TransactionError>;
 }

src/block/mod.rs

@@ -2,69 +2,71 @@ use std::{error::Error, net::Ipv4Addr, time::Duration};
 
 use clap::Parser as _;
 use libp2p::{
-    Multiaddr,
-    gossipsub::{self, AllowAllSubscriptionFilter, Config, IdentityTransform, MessageAuthenticity},
-    kad::{self, store::MemoryStore},
+    Multiaddr, PeerId,
+    kad::{self, Mode, store::MemoryStore},
+    mdns,
     multiaddr::Protocol,
     noise, tcp, yamux,
 };
 use peer_node::{
     cli::Args,
-    network::{
-        behaviour::PeerBehavior,
-        event::{Topic, event_runner},
-    },
+    network::{behaviour::PeerBehavior, event::event_runner},
 };
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
     peer_node::tracing::init("info");
-    let args = Args::parse();
+    let args: Args = Args::parse();
 
-    let ip_addr = Ipv4Addr::new(0, 0, 0, 0);
+    let ip_addr: Ipv4Addr = Ipv4Addr::new(0, 0, 0, 0);
 
-    let peer_multi_addr = Multiaddr::from(ip_addr).with(Protocol::Tcp(0));
+    let peer_multi_addr: Multiaddr = Multiaddr::from(ip_addr).with(Protocol::Tcp(0));
 
     tracing::info!("A {}", args.role);
 
-    let mut swarm = libp2p::SwarmBuilder::with_new_identity()
+    let mut swarm: libp2p::Swarm<PeerBehavior> = libp2p::SwarmBuilder::with_new_identity()
         .with_tokio()
         .with_tcp(
             tcp::Config::default(),
             noise::Config::new,
             yamux::Config::default,
         )?
         .with_behaviour(|keypair| {
-            let peer_id = keypair.public().to_peer_id();
-            let store = MemoryStore::new(peer_id);
-            let kademlia = kad::Behaviour::new(peer_id, store);
+            let peer_id: libp2p::PeerId = keypair.public().to_peer_id();
+            let store: MemoryStore = MemoryStore::new(peer_id);
+            let kademlia: kad::Behaviour<MemoryStore> = kad::Behaviour::new(peer_id, store);
 
-            let gossipsub: gossipsub::Behaviour<IdentityTransform, AllowAllSubscriptionFilter> =
-                gossipsub::Behaviour::new(
-                    MessageAuthenticity::Signed(keypair.clone()),
-                    Config::default(),
-                )
-                .expect("Gossipsub initiation fails");
+            let mdns = mdns::tokio::Behaviour::new(mdns::Config::default(), peer_id)
+                .expect("mDNS initiation fails");
 
-            PeerBehavior {
-                kademlia,
-                gossipsub,
-            }
+            PeerBehavior { kademlia, mdns }
         })?
         .with_swarm_config(|cfg| cfg.with_idle_connection_timeout(Duration::from_secs(u64::MAX)))
         .build();
 
-    let topic = gossipsub::IdentTopic::new("peer-network");
-    swarm.behaviour_mut().gossipsub.subscribe(&topic)?;
+    // Roles to transition
+    match args.role {
+        peer_node::cli::Role::BootstapNode => {
+            swarm.behaviour_mut().kademlia.set_mode(Some(Mode::Server))
+        }
+        peer_node::cli::Role::Sender => swarm.behaviour_mut().kademlia.set_mode(Some(Mode::Client)),
+    }
 
     swarm.listen_on(peer_multi_addr)?;
 
-    event_runner(
-        swarm,
-        args.role,
-        args.peer_mutli_address,
-        args.bootstrap_peer_id,
-        Topic(topic.to_string()),
-    )
-    .await
+    let _bootstrap_peer_id: Option<PeerId> = if let Some(bootstrap_peer_id) = args.bootstrap_peer_id
+    {
+        Some(bootstrap_peer_id.parse()?)
+    } else {
+        None
+    };
+
+    let _bootstrap_peer_mutli_address: Option<Multiaddr> =
+        if let Some(peer_mutli_address) = args.peer_mutli_address {
+            Some(peer_mutli_address.parse()?)
+        } else {
+            None
+        };
+
+    event_runner(swarm).await
 }

src/main.rs

@@ -1,8 +1,8 @@
 use libp2p::swarm::NetworkBehaviour;
-use libp2p::{gossipsub, kad};
+use libp2p::{kad, mdns};
 
 #[derive(NetworkBehaviour)]
 pub struct PeerBehavior {
     pub kademlia: kad::Behaviour<kad::store::MemoryStore>,
-    pub gossipsub: gossipsub::Behaviour,
+    pub mdns: mdns::tokio::Behaviour,
 }