feat: make IpldDag an async_trait

Signed-off-by: ljedrz <[email protected]>

Author: ljedrz

src/dag.rs

@@ -1,23 +1,22 @@
 use crate::error::Error;
 use crate::path::{IpfsPath, IpfsPathError, SubPath};
-use crate::repo::RepoTypes;
-use crate::Ipfs;
+use crate::repo::{Repo, RepoTypes};
+use async_trait::async_trait;
 use bitswap::Block;
 use cid::{Cid, Codec, Version};
 use libipld::block::{decode_ipld, encode_ipld};
 use libipld::ipld::Ipld;
 
-#[derive(Clone, Debug)]
-pub struct IpldDag<Types: RepoTypes> {
-    ipfs: Ipfs<Types>,
-}
+#[async_trait]
+pub trait IpldDag {
+    async fn put_dag(&self, data: Ipld, codec: Codec) -> Result<Cid, Error>;
 
-impl<Types: RepoTypes> IpldDag<Types> {
-    pub fn new(ipfs: Ipfs<Types>) -> Self {
-        IpldDag { ipfs }
-    }
+    async fn get_dag(&self, path: IpfsPath) -> Result<Ipld, Error>;
+}
 
-    pub async fn put(&self, data: Ipld, codec: Codec) -> Result<Cid, Error> {
+#[async_trait]
+impl<T: RepoTypes> IpldDag for Repo<T> {
+    async fn put_dag(&self, data: Ipld, codec: Codec) -> Result<Cid, Error> {
         let bytes = encode_ipld(&data, codec)?;
         let hash = multihash::Sha2_256::digest(&bytes);
         let version = if codec == Codec::DagProtobuf {
@@ -27,24 +26,24 @@ impl<Types: RepoTypes> IpldDag<Types> {
         };
         let cid = Cid::new(version, codec, hash)?;
         let block = Block::new(bytes, cid);
-        let (cid, _) = self.ipfs.repo.put_block(block).await?;
+        let (cid, _) = self.put_block(block).await?;
         Ok(cid)
     }
 
-    pub async fn get(&self, path: IpfsPath) -> Result<Ipld, Error> {
+    async fn get_dag(&self, path: IpfsPath) -> Result<Ipld, Error> {
         let cid = match path.root().cid() {
             Some(cid) => cid,
             None => return Err(anyhow::anyhow!("expected cid")),
         };
-        let mut ipld = decode_ipld(&cid, self.ipfs.repo.get_block(&cid).await?.data())?;
+        let mut ipld = decode_ipld(&cid, self.get_block(&cid).await?.data())?;
         for sub_path in path.iter() {
             if !can_resolve(&ipld, sub_path) {
                 let path = sub_path.to_owned();
                 return Err(IpfsPathError::ResolveError { ipld, path }.into());
             }
             ipld = resolve(ipld, sub_path);
             ipld = match ipld {
-                Ipld::Link(cid) => decode_ipld(&cid, self.ipfs.repo.get_block(&cid).await?.data())?,
+                Ipld::Link(cid) => decode_ipld(&cid, self.get_block(&cid).await?.data())?,
                 ipld => ipld,
             };
         }

src/lib.rs

@@ -350,10 +350,6 @@ impl<Types: IpfsTypes> std::ops::Deref for Ipfs<Types> {
 }
 
 impl<Types: IpfsTypes> Ipfs<Types> {
-    fn dag(&self) -> IpldDag<Types> {
-        IpldDag::new(self.clone())
-    }
-
     fn ipns(&self) -> Ipns<Types> {
         Ipns::new(self.clone())
     }
@@ -401,31 +397,30 @@ impl<Types: IpfsTypes> Ipfs<Types> {
 
     /// Puts an ipld dag node into the ipfs repo.
     pub async fn put_dag(&self, ipld: Ipld) -> Result<Cid, Error> {
-        self.dag()
-            .put(ipld, Codec::DagCBOR)
+        self.repo
+            .put_dag(ipld, Codec::DagCBOR)
             .instrument(self.span.clone())
             .await
     }
 
     /// Gets an ipld dag node from the ipfs repo.
     pub async fn get_dag(&self, path: IpfsPath) -> Result<Ipld, Error> {
-        self.dag().get(path).instrument(self.span.clone()).await
+        self.repo.get_dag(path).instrument(self.span.clone()).await
     }
 
     /// Adds a file into the ipfs repo.
     pub async fn add(&self, path: PathBuf) -> Result<Cid, Error> {
-        let dag = self.dag();
         let file = File::new(path).await?;
         let path = file
-            .put_unixfs_v1(&dag)
+            .put_unixfs_v1(&self.repo)
             .instrument(self.span.clone())
             .await?;
         Ok(path)
     }
 
     /// Gets a file from the ipfs repo.
     pub async fn get(&self, path: IpfsPath) -> Result<File, Error> {
-        File::get_unixfs_v1(&self.dag(), path)
+        File::get_unixfs_v1(&self.repo, path)
             .instrument(self.span.clone())
             .await
     }

src/unixfs/mod.rs

@@ -1,7 +1,7 @@
 use crate::dag::IpldDag;
 use crate::error::Error;
 use crate::path::IpfsPath;
-use crate::repo::RepoTypes;
+use crate::repo::{Repo, RepoTypes};
 use async_std::fs;
 use async_std::io::ReadExt;
 use async_std::path::PathBuf;
@@ -31,20 +31,20 @@ impl File {
     }
 
     pub async fn get_unixfs_v1<T: RepoTypes>(
-        dag: &IpldDag<T>,
+        repo: &Repo<T>,
         path: IpfsPath,
     ) -> Result<Self, Error> {
-        let ipld = dag.get(path).await?;
+        let ipld = repo.get_dag(path).await?;
         let pb_node: PbNode = (&ipld).try_into()?;
         Ok(File { data: pb_node.data })
     }
 
-    pub async fn put_unixfs_v1<T: RepoTypes>(&self, dag: &IpldDag<T>) -> Result<Cid, Error> {
+    pub async fn put_unixfs_v1<T: RepoTypes>(&self, repo: &Repo<T>) -> Result<Cid, Error> {
         let links: Vec<Ipld> = vec![];
         let mut pb_node = BTreeMap::<String, Ipld>::new();
         pb_node.insert("Data".to_string(), self.data.clone().into());
         pb_node.insert("Links".to_string(), links.into());
-        dag.put(pb_node.into(), Codec::DagProtobuf).await
+        repo.put_dag(pb_node.into(), Codec::DagProtobuf).await
     }
 }