Reset source to only contain type definitions

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

10 files changed, 21 insertions, 317 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 9ab8ae9..892ba37 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,29 +16,26 @@ homepage      = "http://github.com/matthiasbeyer/distrox"
 edition       = "2018"
 
 [dependencies]
-# TODO: Replace with thiserror
-anyhow           = "1"
-
-env_logger       = "0.8"
-log              = "0.4"
-
-async-trait      = "0.1"
-chrono           = "0.4"
-cid              = "0.6"
-clap-v3          = "3.0.0-beta.1"
-daglib           = { git = "https://git.sr.ht/~matthiasbeyer/daglib", branch = "master" }
-futures          = "0.3"
-ipfs-embed       = { version = "0.20", features = ["tokio"] }
-libipld          = "0.11"
-libipld-cbor     = "0.11"
+anyhow                 = "1"
+async-trait            = "0.1"
+chrono                 = "0.4"
+cid                    = "0.7"
+clap-v3                = "3.0.0-beta.1"
+daglib                 = { git = "https://git.sr.ht/~matthiasbeyer/daglib", branch = "master" }
+env_logger             = "0.8"
+futures                = "0.3"
+ipfs-api-backend-hyper = { version = "0.2", features = [ "with-hyper-tls" ] }
+log                    = "0.4"
+tokio                  = { version = "1", features = ["full"] }
+mime                   = "0.3"
+libipld-cbor           = "0.12"
+libipld                = "0.12"
 libp2p           = "*"
 libp2p-bitswap   = "*"
 libp2p-core      = "*"
 libp2p-gossipsub = "*"
 libp2p-ping      = "*"
-mime             = "0.3"
 rand_core        = { version = "0.6", features = ["getrandom"] }
 rand_os          = "0.2"
 ed25519-dalek    = "*"
-tokio            = { version = "1", features = ["full"] }
 
diff --git a/src/backend/backend.rs b/src/backend/backend.rs
deleted file mode 100644
index 0d4960e..0000000
--- a/src/backend/backend.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use std::sync::Arc;
-
-use anyhow::Result;
-
-use crate::backend::Id;
-use crate::backend::Node;
-
-#[derive(Clone)]
-pub struct IpfsEmbedBackend {
-    ipfs: Arc<ipfs_embed::Ipfs<ipfs_embed::DefaultParams>>,
-}
-
-impl IpfsEmbedBackend {
-    pub fn ipfs(&self) -> Arc<ipfs_embed::Ipfs<ipfs_embed::DefaultParams>> {
-        self.ipfs.clone()
-    }
-}
-
-#[async_trait::async_trait]
-impl daglib::DagBackend<Id, Node> for IpfsEmbedBackend {
-
-    async fn get(&self, id: Id) -> Result<Option<(Id, Node)>> {
-        log::trace!("GET {:?}", id);
-        let block = self.ipfs.fetch(id.as_ref(), self.ipfs.peers()).await?;
-        let node = block.decode::<libipld::cbor::DagCborCodec, crate::backend::Node>()?;
-        Ok(Some((id, node)))
-    }
-
-    async fn put(&mut self, node: Node) -> Result<Id> {
-        log::trace!("PUT {:?}", node);
-        let block = libipld::block::Block::encode(libipld::cbor::DagCborCodec, libipld::multihash::Code::Blake3_256, &node)?;
-        let cid = Id::from(block.cid().clone());
-        self.ipfs
-            .insert(&block)
-            .map(|_| cid)
-    }
-}
-
-impl IpfsEmbedBackend {
-    pub async fn new_in_memory(cache_size: u64) -> Result<Self> {
-        let in_memory = None; // that's how it works...
-        let config = ipfs_embed::Config::new(in_memory, cache_size);
-
-        ipfs_embed::Ipfs::new(config).await.map(Arc::new).map(|ipfs| IpfsEmbedBackend { ipfs })
-    }
-
-    pub async fn new_with_config(cfg: ipfs_embed::Config) -> Result<Self> {
-        ipfs_embed::Ipfs::new(cfg)
-            .await
-            .map(Arc::new)
-            .map(|ipfs| IpfsEmbedBackend { ipfs })
-    }
-
-    pub async fn write_payload(&self, payload: &crate::backend::Payload) -> Result<cid::Cid> {
-        log::trace!("Write payload: {:?}", payload);
-        let block = libipld::block::Block::encode(libipld::cbor::DagCborCodec, libipld::multihash::Code::Blake3_256, &payload)?;
-
-        log::trace!("Block = {:?}", block);
-        let _ = self.ipfs.insert(&block)?;
-
-        log::trace!("Inserted. CID = {}", block.cid());
-        Ok(block.cid().clone())
-    }
-
-    pub async fn get_payload(&self, cid: &cid::Cid) -> Result<crate::backend::Payload> {
-        let block = self.ipfs.fetch(cid, self.ipfs.peers()).await?;
-        log::trace!("Block = {:?}", block);
-
-        let payload = block.decode::<libipld::cbor::DagCborCodec, crate::backend::Payload>()?;
-        log::trace!("Payload = {:?}", payload);
-
-        Ok(payload)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::backend::Payload;
-
-    #[tokio::test]
-    async fn test_roundtrip_payload() {
-        let _ = env_logger::try_init();
-
-        let backend = IpfsEmbedBackend::new_in_memory(1024).await.unwrap();
-
-        let input_payload = Payload::now_from_text(String::from("test"));
-        log::debug!("Input = {:?}", input_payload);
-        let cid = backend.write_payload(&input_payload).await.unwrap();
-        log::debug!("CID = {:?}", cid);
-        let output_payload = backend.get_payload(&cid).await.unwrap();
-
-        assert_eq!(input_payload, output_payload);
-
-    }
-}
diff --git a/src/main.rs b/src/main.rs
index 4041c3f..e110fa8 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -13,134 +13,14 @@ use futures::stream::StreamExt;
 
 extern crate clap_v3 as clap;
 
-mod backend;
 mod cli;
 mod consts;
-mod profile;
+mod types;
 
 #[tokio::main]
 async fn main() -> Result<()> {
     let _ = env_logger::try_init()?;
     let app = crate::cli::app();
-
-    log::info!("Booting backend");
-    let mut backend = {
-        // Testing configuration for the IPFS node in the backend.
-
-        let tmp = PathBuf::from("/tmp/distrox.tmp");
-        let sconf = ipfs_embed::StorageConfig {
-            path: Some(tmp),
-            cache_size_blocks: 100_000, // blocks kepts before GC
-            cache_size_bytes: 1024 * 1024 * 1024, // 1GB before GC
-            gc_interval: std::time::Duration::from_secs(60 * 60), // hourly
-            gc_min_blocks: 0,
-            gc_target_duration: std::time::Duration::from_secs(60), // 1 minute
-        };
-
-        let mut csprng = OsRng{};
-        let nconf = ipfs_embed::NetworkConfig {
-            node_name: String::from("distrox-devel"),
-            node_key: ipfs_embed::Keypair::generate(&mut csprng),
-
-            quic: ipfs_embed::TransportConfig::default(),
-            psk: None,
-            dns: None,
-            mdns: None,
-            kad: None,
-            ping: None,
-            identify: None,
-            gossipsub: None,
-            broadcast: None,
-            bitswap: None,
-
-        };
-
-        let ipfs_configuration = ipfs_embed::Config {
-            storage: sconf,
-            network: nconf,
-        };
-        crate::backend::IpfsEmbedBackend::new_with_config(ipfs_configuration).await?
-    };
-    log::info!("Backend booted successfully");
-
-    backend.ipfs()
-        .listen_on("/ip4/127.0.0.1/tcp/0".parse()?)?
-        .next()
-        .await
-        .unwrap();
-
-    match app.get_matches().subcommand() {
-        ("create-profile", Some(mtch)) => {
-            log::info!("Creating profile");
-            let payload = mtch
-                .value_of("content")
-                .map(String::from)
-                .map(crate::backend::Payload::now_from_text)
-                .unwrap(); // Safe by clap
-
-            let payload_cid = backend.write_payload(&payload).await?;
-            log::info!("Payload written as {}", payload_cid);
-            let node = crate::backend::Node::new(crate::consts::v1(), vec![], payload_cid);
-
-            log::info!("Writing node for payload");
-            let id = backend.put(node).await?;
-
-            println!("id = {}", id.as_ref());
-            log::info!("Creating profile finished");
-            Ok(())
-        },
-
-        ("post", Some(mtch)) => {
-            let payload = mtch
-                .value_of("content")
-                .map(String::from)
-                .map(crate::backend::Payload::now_from_text)
-                .unwrap(); // Safe by clap
-            let parent = mtch
-                .value_of("head")
-                .map(cid::Cid::from_str)
-                .transpose()?
-                .map(crate::backend::Id::from)
-                .unwrap(); // Safe by clap
-
-            let payload_cid = backend.write_payload(&payload).await?;
-            let node = crate::backend::Node::new(crate::consts::v1(), vec![parent], payload_cid);
-
-            let id = backend.put(node).await?;
-
-            println!("id = {}", id.as_ref());
-            Ok(())
-        },
-
-        ("get", Some(mtch)) => {
-            let head = mtch
-                .value_of("head")
-                .map(cid::Cid::from_str)
-                .transpose()?
-                .map(crate::backend::Id::from)
-                .unwrap(); // Safe by clap
-
-            log::info!("Fetching {} from backend", head.as_ref());
-            let (id, node) = backend
-                .get(head.clone())
-                .await?
-                .ok_or_else(|| anyhow!("Not found: {:?}", head))?;
-
-            log::info!("Fetching payload of {} ({}) from backend", head.as_ref(), node.payload_id());
-            let payload = backend.ipfs().fetch(node.payload_id(), backend.ipfs().peers()).await?;
-            log::debug!("Fetched payload, now decoding...");
-            let payload = payload.decode::<libipld::cbor::DagCborCodec, crate::backend::Payload>()?;
-            log::debug!("Decoding successful");
-
-            println!("id      = {}", id.as_ref());
-            println!("node    = {:?}", node);
-            println!("payload = {:?}", payload);
-            Ok(())
-        },
-
-        (other, _) => {
-            unimplemented!()
-        },
-    }
+    Ok(())
 }
 
diff --git a/src/profile.rs b/src/profile.rs
deleted file mode 100644
index edd8355..0000000
--- a/src/profile.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use std::collections::HashMap;
-
-use anyhow::anyhow;
-use anyhow::Result;
-use daglib::Node as _;
-use daglib::DagBackend;
-
-use crate::backend::Id;
-use crate::backend::Node;
-use crate::backend::IpfsEmbedBackend;
-
-pub struct Profile {
-    dag: daglib::AsyncDag<Id, Node, IpfsEmbedBackend>,
-
-    cache: HashMap<Id, LoadedNode>,
-}
-
-impl Profile {
-    pub async fn load(head: Id) -> Result<Self> {
-        let backend = IpfsEmbedBackend::new_in_memory(1000).await?;
-        let dag = daglib::AsyncDag::load(backend, head).await?;
-        let mut cache = HashMap::new();
-        let (id, node) = LoadedNode::load(dag.backend(), dag.head().clone()).await?;
-        cache.insert(id, node);
-        Ok(Profile { dag, cache })
-    }
-
-    pub async fn create(node: LoadedNode) -> Result<Self> {
-        let backend = IpfsEmbedBackend::new_in_memory(1000).await?;
-        Profile::create_with_backend(backend, node).await
-    }
-
-    pub async fn create_with_backend(backend: IpfsEmbedBackend, loaded_node: LoadedNode) -> Result<Self> {
-        let payload_cid = backend.write_payload(&loaded_node.payload).await?;
-
-        let node = Node::new(loaded_node.v.clone(), loaded_node.parents.clone(), payload_cid);
-
-        let dag = daglib::AsyncDag::new(backend, node).await?;
-        let head = dag.head().clone();
-        let mut cache = HashMap::new();
-        cache.insert(head, loaded_node);
-
-        Ok(Profile { dag, cache })
-    }
-}
-
-pub struct LoadedNode {
-    v: String,
-    parents: Vec<crate::backend::Id>,
-    payload: crate::backend::Payload,
-}
-
-impl LoadedNode {
-    async fn load(backend: &IpfsEmbedBackend, id: Id) -> Result<(Id, LoadedNode)> {
-        let (id, node) = backend
-            .get(id)
-            .await?
-            .ok_or_else(|| anyhow!("No node found"))?;
-
-        let payload = {
-            let ipfs = backend.ipfs();
-            let block = ipfs.fetch(node.payload_id(), ipfs.peers()).await?;
-            block.decode::<libipld::cbor::DagCborCodec, crate::backend::Payload>()?
-        };
-
-        Ok((id, {
-            LoadedNode {
-                v: node.version().to_string(),
-                parents: node.parent_ids().clone(),
-                payload
-            }
-        }))
-    }
-}
diff --git a/src/backend/datetime.rs b/src/types/datetime.rs
index ec99282..ec99282 100644
--- a/src/backend/datetime.rs
+++ b/src/types/datetime.rs
diff --git a/src/backend/id.rs b/src/types/id.rs
index 425d077..425d077 100644
--- a/src/backend/id.rs
+++ b/src/types/id.rs
diff --git a/src/backend/mime.rs b/src/types/mime.rs
index 9ea1cb8..9ea1cb8 100644
--- a/src/backend/mime.rs
+++ b/src/types/mime.rs
diff --git a/src/backend/mod.rs b/src/types/mod.rs
index 2a35e82..afd3168 100644
--- a/src/backend/mod.rs
+++ b/src/types/mod.rs
@@ -4,9 +4,6 @@ pub use id::*;
 mod node;
 pub use node::*;
 
-mod backend;
-pub use backend::*;
-
 mod datetime;
 pub use datetime::*;
 
diff --git a/src/backend/node.rs b/src/types/node.rs
index a068405..89a5c0d 100644
--- a/src/backend/node.rs
+++ b/src/types/node.rs
@@ -4,14 +4,14 @@ pub struct Node {
     v: String,
 
     /// Parent Nodes, identified by cid
-    parents: Vec<crate::backend::Id>,
+    parents: Vec<crate::types::Id>,
 
     /// The actual payload of the node, which is stored in another document identified by this cid
     payload: cid::Cid,
 }
 
 impl daglib::Node for Node {
-    type Id = crate::backend::Id;
+    type Id = crate::types::Id;
 
     fn parent_ids(&self) -> Vec<Self::Id> {
         self.parents.clone()
@@ -26,7 +26,7 @@ impl Node {
         &self.payload
     }
 
-    pub fn new(version: String, parents: Vec<crate::backend::Id>, payload: cid::Cid) -> Self {
+    pub fn new(version: String, parents: Vec<crate::types::Id>, payload: cid::Cid) -> Self {
         Node {
             v: version,
             parents,
diff --git a/src/backend/payload.rs b/src/types/payload.rs
index 6656b7e..fd34aab 100644
--- a/src/backend/payload.rs
+++ b/src/types/payload.rs
@@ -1,5 +1,5 @@
-use crate::backend::DateTime;
-use crate::backend::MimeType;
+use crate::types::DateTime;
+use crate::types::MimeType;
 
 #[derive(Debug, Eq, PartialEq, libipld::DagCbor)]
 pub struct Payload {