Write f64 values

netfetch/src/bsread.rs

@@ -5,7 +5,6 @@ use log::*;
 use netpod::{ByteOrder, ScalarType, Shape};
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsVal;
-use std::fmt;
 
 // TODO
 pub struct ParseError {
@@ -13,50 +12,86 @@ pub struct ParseError {
     pub msg: ZmtpMessage,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct GlobalTimestamp {
     pub sec: u64,
     pub ns: u64,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ChannelDesc {
     pub name: String,
     #[serde(rename = "type")]
     pub ty: String,
     pub shape: JsVal,
     pub encoding: String,
+    pub compression: Option<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct HeadA {
     pub htype: String,
     pub hash: String,
     pub pulse_id: serde_json::Number,
     pub global_timestamp: GlobalTimestamp,
+    pub dh_compression: Option<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct HeadB {
     pub htype: String,
     pub channels: Vec<ChannelDesc>,
 }
 
-#[derive(Debug)]
+impl HeadB {
+    pub fn empty() -> Self {
+        Self {
+            htype: String::new(),
+            channels: vec![],
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
 pub struct BsreadMessage {
     pub head_a: HeadA,
     pub head_b: HeadB,
-    pub values: Vec<Box<dyn fmt::Debug>>,
+    pub head_b_md5: String,
 }
 
 pub fn parse_zmtp_message(msg: &ZmtpMessage) -> Result<BsreadMessage, Error> {
-    if msg.frames().len() < 3 {
+    if msg.frames().len() < 2 {
         return Err(Error::with_msg_no_trace("not enough frames for bsread"));
     }
     let head_a: HeadA = serde_json::from_slice(&msg.frames()[0].data())?;
-    let head_b: HeadB = serde_json::from_slice(&msg.frames()[1].data())?;
-    let mut values = vec![];
-    if msg.frames().len() == head_b.channels.len() + 3 {
+    let head_b_md5 = {
+        use md5::Digest;
+        let mut hasher = md5::Md5::new();
+        hasher.update(msg.frames()[1].data());
+        let h = hasher.finalize();
+        hex::encode(&h)
+    };
+    let dhdecompr = match &head_a.dh_compression {
+        Some(m) => match m.as_str() {
+            "none" => msg.frames()[1].data(),
+            "lz4" => {
+                error!("data header lz4 compression not yet implemented");
+                return Err(Error::with_msg_no_trace(
+                    "data header lz4 compression not yet implemented",
+                ));
+            }
+            "bitshuffle_lz4" => {
+                error!("data header bitshuffle_lz4 compression not yet implemented");
+                return Err(Error::with_msg_no_trace(
+                    "data header bitshuffle_lz4 compression not yet implemented",
+                ));
+            }
+            _ => msg.frames()[1].data(),
+        },
+        None => msg.frames()[1].data(),
+    };
+    let head_b: HeadB = serde_json::from_slice(dhdecompr)?;
+    if false && msg.frames().len() == head_b.channels.len() + 3 {
         for (ch, fr) in head_b.channels.iter().zip(msg.frames()[2..].iter()) {
             let sty = ScalarType::from_bsread_str(ch.ty.as_str())?;
             let bo = ByteOrder::from_bsread_str(&ch.encoding)?;
@@ -66,8 +101,7 @@ pub fn parse_zmtp_message(msg: &ZmtpMessage) -> Result<BsreadMessage, Error> {
                     ByteOrder::LE => match &shape {
                         Shape::Scalar => {
                             assert_eq!(fr.data().len(), 8);
-                            let v = i64::from_le_bytes(fr.data().try_into()?);
-                            values.push(Box::new(v) as _);
+                            let _v = i64::from_le_bytes(fr.data().try_into()?);
                         }
                         Shape::Wave(_) => {}
                         Shape::Image(_, _) => {}
@@ -78,14 +112,11 @@ pub fn parse_zmtp_message(msg: &ZmtpMessage) -> Result<BsreadMessage, Error> {
             }
         }
     }
-    {
-        let fr = &msg.frames()[msg.frames().len() - 1];
-        if fr.data().len() == 8 {
-            let pulse = u64::from_le_bytes(fr.data().try_into()?);
-            info!("pulse {}", pulse);
-        }
-    }
-    let ret = BsreadMessage { head_a, head_b, values };
+    let ret = BsreadMessage {
+        head_a,
+        head_b,
+        head_b_md5,
+    };
     Ok(ret)
 }