refactor: depend in p2p::Behaviour on Arc<Repo<_>>

... instead of Ipfs. this was the original idea in #343 perhaps.

Author: Joonas Koivunen

src/lib.rs

@@ -415,18 +415,22 @@ impl<Types: IpfsTypes> UninitializedIpfs<Types> {
 
         let (to_task, receiver) = channel::<IpfsEvent>(1);
 
+        let facade_span = options
+            .span
+            .take()
+            .unwrap_or_else(|| tracing::trace_span!("ipfs"));
+
+        let swarm_span = tracing::trace_span!(parent: facade_span.clone(), "swarm");
+
         let ipfs = Ipfs {
-            span: options
-                .span
-                .take()
-                .unwrap_or_else(|| tracing::trace_span!("ipfs")),
-            repo,
+            span: facade_span,
+            repo: repo.clone(),
             keys: DebuggableKeypair(keys),
             to_task,
         };
 
         let swarm_options = SwarmOptions::from(&options);
-        let swarm = create_swarm(swarm_options, ipfs.clone()).await?;
+        let swarm = create_swarm(swarm_options, swarm_span, repo).await?;
 
         let IpfsOptions {
             listening_addrs, ..

src/p2p/behaviour.rs

@@ -2,9 +2,9 @@ use super::pubsub::Pubsub;
 use super::swarm::{Connection, Disconnector, SwarmApi};
 use crate::config::BOOTSTRAP_NODES;
 use crate::p2p::{MultiaddrWithPeerId, SwarmOptions};
-use crate::repo::BlockPut;
+use crate::repo::{BlockPut, Repo};
 use crate::subscription::{SubscriptionFuture, SubscriptionRegistry};
-use crate::{Ipfs, IpfsTypes};
+use crate::IpfsTypes;
 use anyhow::anyhow;
 use bitswap::{Bitswap, BitswapEvent};
 use cid::Cid;
@@ -16,16 +16,15 @@ use libp2p::mdns::{MdnsEvent, TokioMdns};
 use libp2p::ping::{Ping, PingEvent};
 use libp2p::swarm::toggle::Toggle;
 use libp2p::swarm::{NetworkBehaviour, NetworkBehaviourEventProcess};
-use libp2p::NetworkBehaviour;
 use multibase::Base;
 use std::{convert::TryInto, sync::Arc};
 use tokio::task;
 
 /// Behaviour type.
-#[derive(NetworkBehaviour)]
+#[derive(libp2p::NetworkBehaviour)]
 pub struct Behaviour<Types: IpfsTypes> {
     #[behaviour(ignore)]
-    ipfs: Ipfs<Types>,
+    repo: Arc<Repo<Types>>,
     mdns: Toggle<TokioMdns>,
     kademlia: Kademlia<MemoryStore>,
     #[behaviour(ignore)]
@@ -314,11 +313,11 @@ impl<Types: IpfsTypes> NetworkBehaviourEventProcess<BitswapEvent> for Behaviour<
     fn inject_event(&mut self, event: BitswapEvent) {
         match event {
             BitswapEvent::ReceivedBlock(peer_id, block) => {
-                let ipfs = self.ipfs.clone();
+                let repo = self.repo.clone();
                 let peer_stats = Arc::clone(&self.bitswap.stats.get(&peer_id).unwrap());
                 task::spawn(async move {
                     let bytes = block.data().len() as u64;
-                    let res = ipfs.repo.put_block(block.clone()).await;
+                    let res = repo.put_block(block.clone()).await;
                     match res {
                         Ok((_, uniqueness)) => match uniqueness {
                             BlockPut::NewBlock => peer_stats.update_incoming_unique(bytes),
@@ -343,10 +342,10 @@ impl<Types: IpfsTypes> NetworkBehaviourEventProcess<BitswapEvent> for Behaviour<
                 );
 
                 let queued_blocks = self.bitswap().queued_blocks.clone();
-                let ipfs = self.ipfs.clone();
+                let repo = self.repo.clone();
 
                 task::spawn(async move {
-                    match ipfs.repo.get_block_now(&cid).await {
+                    match repo.get_block_now(&cid).await {
                         Ok(Some(block)) => {
                             let _ = queued_blocks.unbounded_send((peer_id, block));
                         }
@@ -413,7 +412,7 @@ impl<Types: IpfsTypes> NetworkBehaviourEventProcess<IdentifyEvent> for Behaviour
 
 impl<Types: IpfsTypes> Behaviour<Types> {
     /// Create a Kademlia behaviour with the IPFS bootstrap nodes.
-    pub async fn new(options: SwarmOptions, ipfs: Ipfs<Types>) -> Self {
+    pub async fn new(options: SwarmOptions, repo: Arc<Repo<Types>>) -> Self {
         info!("net: starting with peer id {}", options.peer_id);
 
         let mdns = if options.mdns {
@@ -454,7 +453,7 @@ impl<Types: IpfsTypes> Behaviour<Types> {
         }
 
         Behaviour {
-            ipfs,
+            repo,
             mdns,
             kademlia,
             kad_subscriptions: Default::default(),
@@ -646,7 +645,7 @@ impl<Types: IpfsTypes> Behaviour<Types> {
 /// Create a IPFS behaviour with the IPFS bootstrap nodes.
 pub async fn build_behaviour<TIpfsTypes: IpfsTypes>(
     options: SwarmOptions,
-    ipfs: Ipfs<TIpfsTypes>,
+    repo: Arc<Repo<TIpfsTypes>>,
 ) -> Behaviour<TIpfsTypes> {
-    Behaviour::new(options, ipfs).await
+    Behaviour::new(options, repo).await
 }

src/p2p/mod.rs

@@ -1,9 +1,11 @@
 //! P2P handling for IPFS nodes.
-use crate::{Ipfs, IpfsOptions, IpfsTypes};
+use crate::repo::Repo;
+use crate::{IpfsOptions, IpfsTypes};
 use libp2p::identity::Keypair;
 use libp2p::Swarm;
 use libp2p::{Multiaddr, PeerId};
 use std::io;
+use std::sync::Arc;
 use tracing::Span;
 
 pub(crate) mod addr;
@@ -46,17 +48,16 @@ impl From<&IpfsOptions> for SwarmOptions {
 /// Creates a new IPFS swarm.
 pub async fn create_swarm<TIpfsTypes: IpfsTypes>(
     options: SwarmOptions,
-    ipfs: Ipfs<TIpfsTypes>,
+    swarm_span: Span,
+    repo: Arc<Repo<TIpfsTypes>>,
 ) -> io::Result<TSwarm<TIpfsTypes>> {
     let peer_id = options.peer_id.clone();
 
     // Set up an encrypted TCP transport over the Mplex protocol.
     let transport = transport::build_transport(options.keypair.clone())?;
 
-    let swarm_span = ipfs.span.clone();
-
     // Create a Kademlia behaviour
-    let behaviour = behaviour::build_behaviour(options, ipfs).await;
+    let behaviour = behaviour::build_behaviour(options, repo).await;
 
     // Create a Swarm
     let swarm = libp2p::swarm::SwarmBuilder::new(transport, behaviour, peer_id)