feat: Add from_iter and via_iter for operator

bin/oay/src/bin/oay.rs

@@ -45,7 +45,7 @@ async fn s3() -> Result<()> {
     let cfg: Config =
         toml::from_str(&std::fs::read_to_string("oay.toml").context("failed to open oay.toml")?)?;
     let scheme = Scheme::from_str(&cfg.backend.typ).context("unsupported scheme")?;
-    let op = Operator::via_map(scheme, cfg.backend.map.clone())?;
+    let op = Operator::via_iter(scheme, cfg.backend.map.clone())?;
 
     let s3 = S3Service::new(Arc::new(cfg), op);
 

bin/ofs/src/main.rs

@@ -68,7 +68,7 @@ async fn execute(cfg: Config) -> Result<()> {
         Ok(Scheme::Custom(_)) | Err(_) => Err(anyhow!("invalid scheme: {}", scheme_str)),
         Ok(s) => Ok(s),
     }?;
-    let backend = Operator::via_map(scheme, op_args)?;
+    let backend = Operator::via_iter(scheme, op_args)?;
 
     let mut mount_options = MountOptions::default();
     let mut gid = nix::unistd::getgid().into();

bin/oli/src/config/mod.rs

@@ -162,114 +162,8 @@ impl Config {
             .get("type")
             .ok_or_else(|| anyhow!("missing 'type' in profile"))?;
         let scheme = Scheme::from_str(svc)?;
-        match scheme {
-            Scheme::Azblob => Ok((
-                Operator::from_map::<services::Azblob>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::Azdls => Ok((
-                Operator::from_map::<services::Azdls>(profile.clone())?.finish(),
-                path,
-            )),
-            #[cfg(feature = "services-dashmap")]
-            Scheme::Dashmap => Ok((
-                Operator::from_map::<services::Dashmap>(profile.clone())?.finish(),
-                path,
-            )),
-            #[cfg(feature = "services-etcd")]
-            Scheme::Etcd => Ok((
-                Operator::from_map::<services::Etcd>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::Gcs => Ok((
-                Operator::from_map::<services::Gcs>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::Ghac => Ok((
-                Operator::from_map::<services::Ghac>(profile.clone())?.finish(),
-                path,
-            )),
-            #[cfg(feature = "services-hdfs")]
-            Scheme::Hdfs => Ok((
-                Operator::from_map::<services::Hdfs>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::Http => Ok((
-                Operator::from_map::<services::Http>(profile.clone())?.finish(),
-                path,
-            )),
-            #[cfg(feature = "services-ftp")]
-            Scheme::Ftp => Ok((
-                Operator::from_map::<services::Ftp>(profile.clone())?.finish(),
-                path,
-            )),
-            #[cfg(feature = "services-ipfs")]
-            Scheme::Ipfs => Ok((
-                Operator::from_map::<services::Ipfs>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::Ipmfs => Ok((
-                Operator::from_map::<services::Ipmfs>(profile.clone())?.finish(),
-                path,
-            )),
-            #[cfg(feature = "services-memcached")]
-            Scheme::Memcached => Ok((
-                Operator::from_map::<services::Memcached>(profile.clone())?.finish(),
-                path,
-            )),
-            // ignore the memory backend
-            #[cfg(feature = "services-mini-moka")]
-            Scheme::MiniMoka => Ok((
-                Operator::from_map::<services::MiniMoka>(profile.clone())?.finish(),
-                path,
-            )),
-            // ignore the memory backend
-            #[cfg(feature = "services-moka")]
-            Scheme::Moka => Ok((
-                Operator::from_map::<services::Moka>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::Obs => Ok((
-                Operator::from_map::<services::Obs>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::Oss => Ok((
-                Operator::from_map::<services::Oss>(profile.clone())?.finish(),
-                path,
-            )),
-            #[cfg(feature = "services-redis")]
-            Scheme::Redis => Ok((
-                Operator::from_map::<services::Redis>(profile.clone())?.finish(),
-                path,
-            )),
-            #[cfg(feature = "services-rocksdb")]
-            Scheme::Rocksdb => Ok((
-                Operator::from_map::<services::Rocksdb>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::S3 => Ok((
-                Operator::from_map::<services::S3>(profile.clone())?.finish(),
-                path,
-            )),
-            #[cfg(feature = "services-sled")]
-            Scheme::Sled => Ok((
-                Operator::from_map::<services::Sled>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::Webdav => Ok((
-                Operator::from_map::<services::Webdav>(profile.clone())?.finish(),
-                path,
-            )),
-            Scheme::Webhdfs => Ok((
-                Operator::from_map::<services::Webhdfs>(profile.clone())?.finish(),
-                path,
-            )),
-            _ => Err(anyhow!(
-                "unknown type '{}' in profile '{}'",
-                scheme,
-                profile_name
-            )),
-        }
+        let op = Operator::via_iter(scheme, profile.clone())?;
+        Ok((op, path))
     }
 }
 

core/src/raw/tests/utils.rs

@@ -67,7 +67,7 @@ pub fn init_test_service() -> Result<Option<Operator>> {
         cfg.insert("root".to_string(), root);
     }
 
-    let op = Operator::via_map(scheme, cfg).expect("must succeed");
+    let op = Operator::via_iter(scheme, cfg).expect("must succeed");
 
     #[cfg(feature = "layers-chaos")]
     let op = { op.layer(layers::ChaosLayer::new(0.1)) };

core/src/types/context/read.rs

@@ -146,15 +146,14 @@ impl ReadGenerator {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::HashMap;
 
     use bytes::Bytes;
 
     use super::*;
 
     #[tokio::test]
     async fn test_next_reader() -> Result<()> {
-        let op = Operator::via_map(Scheme::Memory, HashMap::default())?;
+        let op = Operator::via_iter(Scheme::Memory, [])?;
         op.write(
             "test",
             Buffer::from(vec![Bytes::from("Hello"), Bytes::from("World")]),
@@ -180,7 +179,7 @@ mod tests {
 
     #[test]
     fn test_next_blocking_reader() -> Result<()> {
-        let op = Operator::via_map(Scheme::Memory, HashMap::default())?;
+        let op = Operator::via_iter(Scheme::Memory, [])?;
         op.blocking().write(
             "test",
             Buffer::from(vec![Bytes::from("Hello"), Bytes::from("World")]),