Store needs to return their url and range

src/lib.rs

@@ -116,6 +116,16 @@ pub async fn unpack<P: AsRef<Path>, S: Store>(
 pub async fn pack<P: AsRef<Path>, S: Store>(meta: Writer, store: S, root: P) -> Result<()> {
     use tokio::fs;
 
+    // building routing table from store information
+    for route in store.routes() {
+        meta.route(
+            route.start.unwrap_or(u8::MIN),
+            route.end.unwrap_or(u8::MAX),
+            route.url,
+        )
+        .await?;
+    }
+
     let store: BlockStore<S> = store.into();
 
     let m = fs::metadata(&root)
@@ -207,7 +217,10 @@ async fn scan<S: Store>(
 
 #[cfg(test)]
 mod test {
-    use crate::{fungi::meta, store::dir::DirStore};
+    use crate::{
+        fungi::meta,
+        store::{dir::DirStore, Router},
+    };
 
     use super::*;
 
@@ -218,7 +231,13 @@ mod test {
     async fn create_meta() {
         let writer = meta::Writer::new("/tmp/build.fl").await.unwrap();
 
-        let store = DirStore::new("/tmp/store").await.unwrap();
+        let store0 = DirStore::new("/tmp/store0").await.unwrap();
+        let store1 = DirStore::new("/tmp/store1").await.unwrap();
+        let mut store = Router::new();
+
+        store.add(0x00, 0x7f, Box::new(store0));
+        store.add(0x80, 0xff, Box::new(store1));
+
         pack(writer, store, "/home/azmy/Documents/Visa Application")
             .await
             .unwrap();

src/store/bs.rs

@@ -82,6 +82,8 @@ where
 
 #[cfg(test)]
 mod test {
+    use super::super::Route;
+
     use super::*;
     use std::collections::HashMap;
     use std::sync::Arc;
@@ -105,6 +107,10 @@ mod test {
 
             Ok(())
         }
+
+        fn routes(&self) -> Vec<Route> {
+            vec![Route::url("mem://")]
+        }
     }
 
     #[tokio::test]

src/store/dir.rs

@@ -1,5 +1,6 @@
-use super::{Error, Result, Store};
+use super::{Error, Result, Route, Store};
 use std::io::ErrorKind;
+use std::os::unix::prelude::OsStrExt;
 use std::path::PathBuf;
 use tokio::fs;
 
@@ -41,4 +42,13 @@ impl Store for DirStore {
         fs::write(path, blob).await?;
         Ok(())
     }
+
+    fn routes(&self) -> Vec<Route> {
+        let r = Route::url(format!(
+            "dir://{}",
+            String::from_utf8_lossy(self.root.as_os_str().as_bytes())
+        ));
+
+        vec![r]
+    }
 }

src/store/mod.rs

@@ -39,13 +39,29 @@ pub enum Error {
 
 pub type Result<T> = std::result::Result<T, Error>;
 
+pub struct Route {
+    pub start: Option<u8>,
+    pub end: Option<u8>,
+    pub url: String,
+}
+
+impl Route {
+    pub fn url<S: Into<String>>(s: S) -> Self {
+        Self {
+            start: None,
+            end: None,
+            url: s.into(),
+        }
+    }
+}
 /// The store trait defines a simple (low level) key/value store interface to set/get blobs
 /// the concern of the store is to only store given data with given key and implement
 /// the means to retrieve it again once a get is called.
 #[async_trait::async_trait]
 pub trait Store: Send + Sync + 'static {
     async fn get(&self, key: &[u8]) -> Result<Vec<u8>>;
     async fn set(&self, key: &[u8], blob: &[u8]) -> Result<()>;
+    fn routes(&self) -> Vec<Route>;
 }
 
 /// The store factory trait works as a factory for a specific store
@@ -107,4 +123,20 @@ impl Store for Router {
 
         Ok(())
     }
+
+    fn routes(&self) -> Vec<Route> {
+        let mut routes = Vec::default();
+        for (key, value) in self.routes.iter() {
+            for sub in value.routes() {
+                let r = Route {
+                    start: Some(sub.start.unwrap_or(key.start)),
+                    end: Some(sub.end.unwrap_or(key.end)),
+                    url: sub.url,
+                };
+                routes.push(r);
+            }
+        }
+
+        routes
+    }
 }

src/store/router.rs

@@ -4,7 +4,7 @@ use std::ops::Range;
 /// available routers and find that ones that matches this given prefix
 #[derive(Default)]
 pub struct Router<T> {
-    routes: Vec<(Range<u8>, T)>,
+    pub(crate) routes: Vec<(Range<u8>, T)>,
 }
 
 impl<T> Router<T> {

src/store/zdb.rs

@@ -1,4 +1,4 @@
-use super::{Error, Result, Store, StoreFactory};
+use super::{Error, Result, Route, Store, StoreFactory};
 use anyhow::Context;
 
 use bb8_redis::{
@@ -79,6 +79,7 @@ impl StoreFactory for ZdbStoreFactory {
     type Store = ZdbStore;
 
     async fn new<U: AsRef<str> + Send>(&self, u: U) -> anyhow::Result<Self::Store> {
+        let url = u.as_ref().to_owned();
         let (mut info, namespace) = self.get_connection_info(u)?;
 
         let namespace = WithNamespace {
@@ -95,12 +96,13 @@ impl StoreFactory for ZdbStoreFactory {
             .build(mgr)
             .await?;
 
-        Ok(ZdbStore { pool })
+        Ok(ZdbStore { url, pool })
     }
 }
 
 #[derive(Clone)]
 pub struct ZdbStore {
+    url: String,
     pool: Pool<RedisConnectionManager>,
 }
 
@@ -128,6 +130,10 @@ impl Store for ZdbStore {
 
         Ok(())
     }
+
+    fn routes(&self) -> Vec<Route> {
+        vec![Route::url(self.url.clone())]
+    }
 }
 
 #[cfg(test)]