Move types into separate module

archapp/src/events.rs

@@ -1,9 +1,10 @@
+use crate::parse::PbFileReader;
 use err::Error;
 use futures_core::Stream;
 use items::Framable;
-use netpod::log::*;
 use netpod::query::RawEventsQuery;
 use netpod::{ArchiverAppliance, Channel, ChannelInfo, NodeConfigCached, Shape};
+use serde_json::Value as JsonValue;
 use std::pin::Pin;
 
 pub async fn make_event_pipe(
@@ -24,11 +25,24 @@ pub async fn channel_info(channel: &Channel, node_config: &NodeConfigCached) ->
         .unwrap()
         .data_base_path
         .clone();
-    let path2 = a.iter().fold(path1, |a, &x| a.join(x));
-    info!("path2: {}", path2.to_str().unwrap());
+    let path2 = a.iter().take(a.len() - 1).fold(path1, |a, &x| a.join(x));
+    let mut msgs = vec![];
+    msgs.push(format!("a: {:?}", a));
+    msgs.push(format!("path2: {}", path2.to_string_lossy()));
+    let mut rd = tokio::fs::read_dir(&path2).await?;
+    while let Some(de) = rd.next_entry().await? {
+        let s = de.file_name().to_string_lossy().into_owned();
+        if s.starts_with(a.last().unwrap()) && s.ends_with(".pb") {
+            msgs.push(s);
+            let f1 = tokio::fs::File::open(de.path()).await?;
+            let mut pbr = PbFileReader::new(f1).await;
+            pbr.read_header().await?;
+            msgs.push(format!("got header {}", pbr.channel_name()));
+        }
+    }
     let ret = ChannelInfo {
         shape: Shape::Scalar,
-        msg: format!("{:?}  path2: {:?}", a, path2),
+        msg: JsonValue::Array(msgs.into_iter().map(JsonValue::String).collect()),
     };
     Ok(ret)
 }

archapp/src/parse.rs

@@ -1,3 +1,4 @@
+use crate::generated::EPICSEvent::PayloadType;
 use crate::unescape_archapp_msg;
 use archapp_xc::*;
 use async_channel::{bounded, Receiver};
@@ -8,10 +9,104 @@ use protobuf::Message;
 use serde::Serialize;
 use serde_json::Value as JsonValue;
 use std::collections::{BTreeMap, VecDeque};
-use std::path::PathBuf;
 use std::sync::Arc;
+use tokio::fs::File;
 use tokio::io::AsyncReadExt;
 
+pub struct PbFileReader {
+    file: File,
+    buf: Vec<u8>,
+    wp: usize,
+    rp: usize,
+    channel_name: String,
+    payload_type: PayloadType,
+}
+
+impl PbFileReader {
+    pub async fn new(file: File) -> Self {
+        Self {
+            file,
+            buf: vec![0; 1024 * 128],
+            wp: 0,
+            rp: 0,
+            channel_name: String::new(),
+            payload_type: PayloadType::V4_GENERIC_BYTES,
+        }
+    }
+
+    pub async fn read_header(&mut self) -> Result<(), Error> {
+        self.fill_buf().await?;
+        let k = self.find_next_nl()?;
+        let buf = &mut self.buf;
+        let m = unescape_archapp_msg(&buf[self.rp..k])?;
+        let payload_info = crate::generated::EPICSEvent::PayloadInfo::parse_from_bytes(&m)
+            .map_err(|_| Error::with_msg("can not parse PayloadInfo"))?;
+        self.channel_name = payload_info.get_pvname().into();
+        self.payload_type = payload_info.get_field_type();
+        self.rp = k + 1;
+        Ok(())
+    }
+
+    pub async fn read_msg(&mut self) -> Result<(), Error> {
+        self.fill_buf().await?;
+        let k = self.find_next_nl()?;
+        let buf = &mut self.buf;
+        let m = unescape_archapp_msg(&buf[self.rp..k])?;
+        // TODO
+        // Handle the different types.
+        // Must anyways reuse the Events NTY types. Where are they?
+        // Attempt with big enum...
+        let msg = crate::generated::EPICSEvent::VectorFloat::parse_from_bytes(&m)
+            .map_err(|_| Error::with_msg("can not parse VectorFloat"))?;
+        self.rp = k + 1;
+        Ok(())
+    }
+
+    async fn fill_buf(&mut self) -> Result<(), Error> {
+        if self.wp - self.rp >= 1024 * 16 {
+            return Ok(());
+        }
+        if self.rp >= 1024 * 42 {
+            let n = self.wp - self.rp;
+            for i in 0..n {
+                self.buf[i] = self.buf[self.rp + i];
+            }
+            self.rp = 0;
+            self.wp = n;
+        }
+        let buf = &mut self.buf;
+        loop {
+            let sl = &mut buf[self.wp..];
+            if sl.len() == 0 {
+                break;
+            }
+            let n = self.file.read(sl).await?;
+            if n == 0 {
+                break;
+            } else {
+                self.wp += n;
+            }
+        }
+        Ok(())
+    }
+
+    fn find_next_nl(&self) -> Result<usize, Error> {
+        let buf = &self.buf;
+        let mut k = self.rp;
+        while k < self.wp && buf[k] != 0xa {
+            k += 1;
+        }
+        if k == self.wp {
+            return Err(Error::with_msg("no header in pb file"));
+        }
+        Ok(k)
+    }
+
+    pub fn channel_name(&self) -> &str {
+        &self.channel_name
+    }
+}
+
 #[derive(Serialize)]
 pub struct EpicsEventPayloadInfo {
     headers: Vec<(String, String)>,
@@ -22,8 +117,7 @@ pub struct EpicsEventPayloadInfo {
     val0: f32,
 }
 
-async fn read_pb_file(path: PathBuf) -> Result<EpicsEventPayloadInfo, Error> {
-    let mut f1 = tokio::fs::File::open(path).await?;
+async fn read_pb_file(mut f1: File) -> Result<(EpicsEventPayloadInfo, File), Error> {
     let mut buf = vec![0; 1024 * 4];
     {
         let mut i1 = 0;
@@ -120,7 +214,7 @@ async fn read_pb_file(path: PathBuf) -> Result<EpicsEventPayloadInfo, Error> {
                     z.datatype = format!("{:?}", ft);
                     z.ts0 = ts;
                     z.val0 = val;
-                    return Ok(z);
+                    return Ok((z, f1));
                 }
             }
         } else {
@@ -182,7 +276,8 @@ pub async fn scan_files_inner(
                         .ok_or_else(|| Error::with_msg("invalid path string"))?
                         .ends_with(".pb")
                     {
-                        let packet = read_pb_file(path.clone()).await?;
+                        let f1 = tokio::fs::File::open(&path).await?;
+                        let (packet, f1) = read_pb_file(f1).await?;
                         let pvn = packet.pvname.replace("-", "/");
                         let pvn = pvn.replace(":", "/");
                         let pre = "/arch/lts/ArchiverStore/";