Refactor

netfetch/Cargo.toml

@@ -18,3 +18,4 @@ futures-core = "0.3.14"
 futures-util = "0.3.14"
 err = { path = "../err" }
 netpod = { path = "../netpod" }
+taskrun = { path = "../taskrun" }

netfetch/src/lib.rs

@@ -4,6 +4,7 @@ use err::Error;
 use futures_util::FutureExt;
 use netpod::NodeConfigCached;
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -20,15 +21,64 @@ pub enum FetchItem {
     Message(Message),
 }
 
+#[cfg(test)]
+mod test {
+    use futures_util::StreamExt;
+    use netpod::log::*;
+    use netpod::{Cluster, Database, Node, NodeConfig, NodeConfigCached};
+    use std::collections::BTreeMap;
+    use std::iter::FromIterator;
+
+    #[test]
+    fn ca_connect_1() {
+        taskrun::run(async {
+            let it = vec![(String::new(), String::new())].into_iter();
+            let pairs = BTreeMap::from_iter(it);
+            let node_config = NodeConfigCached {
+                node: Node {
+                    host: "".into(),
+                    bin_grain_kind: 0,
+                    port: 123,
+                    port_raw: 123,
+                    backend: "".into(),
+                    split: 0,
+                    data_base_path: "".into(),
+                    listen: "".into(),
+                    ksprefix: "".into(),
+                },
+                node_config: NodeConfig {
+                    name: "".into(),
+                    cluster: Cluster {
+                        nodes: vec![],
+                        database: Database {
+                            host: "".into(),
+                            name: "".into(),
+                            user: "".into(),
+                            pass: "".into(),
+                        },
+                    },
+                },
+                ix: 0,
+            };
+            let mut rx = super::ca_connect_1(pairs, &node_config).await?;
+            while let Some(item) = rx.next().await {
+                info!("got next: {:?}", item);
+            }
+            Ok(())
+        })
+        .unwrap();
+    }
+}
+
 pub async fn ca_connect_1(
-    addr: String,
+    _pairs: BTreeMap<String, String>,
     _node_config: &NodeConfigCached,
 ) -> Result<Receiver<Result<FetchItem, Error>>, Error> {
     let (tx, rx) = bounded(16);
     let tx2 = tx.clone();
     tokio::task::spawn(
         async move {
-            let mut conn = tokio::net::TcpStream::connect(addr).await?;
+            let mut conn = tokio::net::TcpStream::connect("S30CB06-CVME-LLRF2.psi.ch:5064").await?;
             let (mut inp, mut out) = conn.split();
             tx.send(Ok(FetchItem::Log(format!("connected")))).await?;
             let mut buf = [0; 64];